RzCore

class RzCore

property analysis: RzAnalysis

property asmqjmps: int

property asmqjmps_count: int

property asmqjmps_size: int

property _autocomplete: RzCoreAutocomplete

property autocomplete_type: int

property bin: RzBin

property binat: bool

property block: int

property blocksize: int

property blocksize_max: int

property break_loop: bool

property c2: RzCore

property cmd_descriptors: RzList[RzCmdDescriptor]

property cmd_in_backticks: bool

property cmdfilter: str

property cmdlog: str

property cmdqueue: str

property cmdremote: str

property cmdrepeat: int

property cmdtimes: str

property config: RzConfig

property cons: RzCons

property curtab: int

property curtheme: str

property dbg: RzDebug

property egg: RzEgg

property ev: RzEvent

property file: RzCoreFile

property files: RzList[RzCoreFile]

property fixedarch: bool

property fixedbits: bool

property fixedblock: bool

property flags: RzFlag

property gadgets: RzList[RzCoreGadget]

property gdbserver_up: int

property graph: RzAGraph

property hash: RzHash

property http_up: int

property in_search: bool

property incomment: int

property interrupted: int

property io: RzIO

property is_asmqjmps_letter: bool

property is_lastcmd: bool

property is_pipe: bool

property keep_asmqjmps: bool

property lang: RzLang

property lastcmd: str

property lastsearch: str

property lib: RzLib

property log_events: bool

property marks: int

property marks_init: bool

property max_cmd_depth: int

property maxtab: int

property num: RzNum

property offset: int

property panels: RzPanels

property panels_root: RzPanelsRoot

property parser: RzParse

property plugins: RzList[RzCorePlugin]

property print: RzPrint

property printidx: RzCoreVisualMode

property prompt_offset: int

property rasm: RzAsm

property rc: int

property rcmd: RzCmd

property root_cmd_descriptor: RzCmdDescriptor

property ropchain: RzList[char]

property rtr_host: RzCoreRtrHost

property rtr_n: int

property rz_main_rizin: RzMainCallback

property rz_main_rz_asm: CFunction[[int, Pointer[Pointer[int]]], int]

property rz_main_rz_ax: CFunction[[int, Pointer[Pointer[int]]], int]

property rz_main_rz_bin: CFunction[[int, Pointer[Pointer[int]]], int]

property rz_main_rz_diff: CFunction[[int, Pointer[Pointer[int]]], int]

property rz_main_rz_find: CFunction[[int, Pointer[Pointer[int]]], int]

property rz_main_rz_gg: CFunction[[int, Pointer[Pointer[int]]], int]

property rz_main_rz_run: CFunction[[int, Pointer[Pointer[int]]], int]

property scr_gadgets: bool

property scriptstack: RzList[char]

property sdb: Sdb

property search: RzSearch

property seek_history: RzCoreSeekHistory

property seltab: int

property stkcmd: str

property switch_file_view: int

property table_query: str

property tasks: RzCoreTaskScheduler

property times: RzCoreTimes

property tmpseek: bool

property _visual: RzCoreVisual

property visual_inputing: str

property visual_is_inputing: bool

property vmode: bool

property watchers: RzList[RzCoreCmpWatcher]

property yank_addr: int

property yank_buf: RzBuffer

static analysis_hint_list_print(state: RzCmdStateOutput) → None

Calls function rz_core_analysis_hint_list_print (defined in canalysis.c)

static analysis_hint_print(addr: int, state: RzCmdStateOutput) → None

Calls function rz_core_analysis_hint_print (defined in canalysis.c)

static analysis_name_free() → None

Calls function rz_core_analysis_name_free (defined in canalysis.c)

static analysis_name_type_to_str() → str

Calls function rz_core_analysis_name_type_to_str (defined in canalysis.c)

Convert typ to string (const char*)

static analysis_stats_free() → None

Calls function rz_core_analysis_stats_free (defined in canalysis.c)

static analysis_stats_get_block_from(i: size_t) → int

Calls function rz_core_analysis_stats_get_block_from (defined in canalysis.c)

Get the lowest address that the i-th block in s covers (inclusive)

static analysis_stats_get_block_to(i: size_t) → int

Calls function rz_core_analysis_stats_get_block_to (defined in canalysis.c)

Get the highest address that the i-th block in s covers (inclusive)

static annotated_code_print(line_offsets: RzVector[ut64]) → None

Calls function rz_core_annotated_code_print (defined in cannotated_code.c)

static annotated_code_print_comment_cmds() → None

Calls function rz_core_annotated_code_print_comment_cmds (defined in cannotated_code.c)

static annotated_code_print_json() → None

Calls function rz_core_annotated_code_print_json (defined in cannotated_code.c)

static asm_hit_free() → None

Calls function rz_core_asm_hit_free (defined in casm.c)

static asm_hit_list_new() → RzList[RzCoreAsmHit]

Calls function rz_core_asm_hit_list_new (defined in casm.c)

static asm_hit_new() → RzCoreAsmHit

Calls function rz_core_asm_hit_new (defined in casm.c)

static autocomplete_add(cmd: str, type: int, lock: bool) → RzCoreAutocomplete

Calls function rz_core_autocomplete_add (defined in core.c)

static autocomplete_find(cmd: str, exact: bool) → RzCoreAutocomplete

Calls function rz_core_autocomplete_find (defined in core.c)

static autocomplete_free() → None

Calls function rz_core_autocomplete_free (defined in core.c)

static autocomplete_remove(cmd: str) → bool

Calls function rz_core_autocomplete_remove (defined in core.c)

static bin_archs_print(state: RzCmdStateOutput) → bool

Calls function rz_core_bin_archs_print (defined in cbin.c)

static bin_class_build_flag_name() → str

Calls function rz_core_bin_class_build_flag_name (defined in cbin.c)

Returns the flag name of a class.

static bin_dwarf_print_abbrev_section() → None

Calls function rz_core_bin_dwarf_print_abbrev_section (defined in cdwarf.c)

static bin_dwarf_print_aranges() → None

Calls function rz_core_bin_dwarf_print_aranges (defined in cdwarf.c)

static bin_dwarf_print_attr_value() → None

Calls function rz_core_bin_dwarf_print_attr_value (defined in cdwarf.c)

static bin_dwarf_print_debug_info() → None

Calls function rz_core_bin_dwarf_print_debug_info (defined in cdwarf.c)

static bin_dwarf_print_line_units() → None

Calls function rz_core_bin_dwarf_print_line_units (defined in cdwarf.c)

static bin_dwarf_print_loc(addr_size: int) → None

Calls function rz_core_bin_dwarf_print_loc (defined in cdwarf.c)

static bin_field_build_flag_name(field: RzBinField) → str

Calls function rz_core_bin_field_build_flag_name (defined in cbin.c)

Returns the flag name of a class field.

static bin_get_compile_time() → str

Calls function rz_core_bin_get_compile_time (defined in cbin.c)

Get TimeDateStamp string from bf->sdb with key “info.image_file_header.TimeDateStamp_string”.

static bin_method_build_flag_name(meth: RzBinSymbol) → str

Calls function rz_core_bin_method_build_flag_name (defined in cbin.c)

Returns the flag name of a class method.

static bin_method_flags_str(mode: int) → str

Calls function rz_core_bin_method_flags_str (defined in cbin.c)

static bin_pdb_gvars_as_string(img_base: int, pj: PJ, mode: RzOutputMode) → str

Calls function rz_core_bin_pdb_gvars_as_string (defined in cpdb.c)

Return the PDB global vars string.

Parameters:

• pdb – PDB instance

• img_base – image base addr

• pj – JSON instance

• mode – RzOutputMode

Returns:

char *

static bin_plugins_print(state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_bin_plugins_print (defined in cbin.c)

static bin_super_build_flag_name() → str

Calls function rz_core_bin_super_build_flag_name (defined in cbin.c)

Returns the flag name of a super class.

static cast() → RzCore

Calls function rz_core_cast (defined in core.c)

static cmd_new() → RzCmd

Calls function rz_core_cmd_new (defined in cmd.c)

Create an instance of RzCmd for the Rizin language.

static cmd_task_get_result() → str

Calls function rz_core_cmd_task_get_result (defined in task.c)

Get the result of the command that was run in a task created with rz_core_cmd_task_new. If the task is not a command task, returns NULL.

static config_print_all(str: str, state: RzCmdStateOutput) → None

Calls function rz_core_config_print_all (defined in cconfig.c)

Prints the configuation variables with their description and its values.

Parameters:

• cfg – reference to RzConfig

• str – reference to the key that can be passed to filter the output

• state – reference to RzCmdStateOutput

static esil_cmd(cmd: str, a1: int, a2: int) → bool

Calls function rz_core_esil_cmd (defined in cconfig.c)

static esil_dumpstack() → bool

Calls function rz_core_esil_dumpstack (defined in cmd_analysis.c)

static fgets(len: int, user: Any) → int

Calls function rz_core_fgets (defined in core.c)

static file_close() → None

Calls function rz_core_file_close (defined in cfile.c)

static flag_get_by_spaces(off: int) → RzFlagItem

Calls function rz_core_flag_get_by_spaces (defined in core.c)

static flirt_app_from_option_list() → int

Calls function rz_core_flirt_app_from_option_list (defined in csign.c)

Returns the FLIRT file flags from a given list (comma spaced) of file types Returns RZ_FLIRT_SIG_APP_ALL if file_list is “any” and 0 if no valid value is not found.

Parameters:

app_list – The app list to convert to flags

Returns:

The FLIRT app flags.

static flirt_arch_from_id() → str

Calls function rz_core_flirt_arch_from_id (defined in csign.c)

Returns the FLIRT arch name (string format) from a given arch id Returns “unknown” if name is not found.

Parameters:

arch – The arch to convert to string

Returns:

The FLIRT arch name.

static flirt_arch_from_name() → int

Calls function rz_core_flirt_arch_from_name (defined in csign.c)

Returns the FLIRT arch id from a given arch name Returns RZ_FLIRT_SIG_ARCH_ANY if name is not found.

Parameters:

arch – The arch to convert to id

Returns:

The FLIRT arch id.

static flirt_dump_file() → bool

Calls function rz_core_flirt_dump_file (defined in csign.c)

Dumps the contents of a FLIRT file.

Parameters:

flirt_file – FLIRT file name to dump

static flirt_file_from_option_list() → int

Calls function rz_core_flirt_file_from_option_list (defined in csign.c)

Returns the FLIRT file flags from a given list (comma spaced) of file types Returns RZ_FLIRT_SIG_FILE_ALL if file_list is “any” and 0 if no valid value is not found.

Parameters:

file_list – The file list to convert to flags

Returns:

The FLIRT file flags.

static flirt_os_from_option_list() → int

Calls function rz_core_flirt_os_from_option_list (defined in csign.c)

Returns the FLIRT file flags from a given list (comma spaced) of file types Returns RZ_FLIRT_SIG_OS_ALL if file_list is “any” and 0 if no valid value is not found.

Parameters:

os_list – The os list to convert to flags

Returns:

The FLIRT os flags.

static fortune_list_types() → None

Calls function rz_core_fortune_list_types (defined in fortune.c)

static function_task_get_result() → Any

Calls function rz_core_function_task_get_result (defined in task.c)

Get the return value of the function that was run in a task created with rz_core_function_task_new. If the task is not a function task, returns NULL.

static gadget_free() → None

Calls function rz_core_gadget_free (defined in cmd_print.c)

Frees a visual print gadget.

Parameters:

g – reference to RzCoreGadget

static hash_plugins_print(state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_hash_plugins_print (defined in chash.c)

static io_plugins_print(state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_io_plugins_print (defined in cio.c)

Print the registered IO plugins according to state.

Parameters:

• io – Reference to RzIO instance

• state – Specify how plugins shall be printed

static lang_plugins_print(state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_lang_plugins_print (defined in clang.c)

static ncast() → RzCore

Calls function rz_core_ncast (defined in core.c)

static parser_plugins_print(state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_parser_plugins_print (defined in cparser.c)

static seek_item_free() → None

Calls function rz_core_seek_item_free (defined in seek.c)

static sym_is_export() → bool

Calls function rz_core_sym_is_export (defined in cbin.c)

Is RzBinSymbol exported?

static sym_name_fini() → None

Calls function rz_core_sym_name_fini (defined in cbin.c)

RZ_FREE all member of sn (sn->*)

Parameters:

sn – Symbol names

static task_break(id: int) → None

Calls function rz_core_task_break (defined in task.c)

static task_break_all() → None

Calls function rz_core_task_break_all (defined in task.c)

static task_decref() → None

Calls function rz_core_task_decref (defined in task.c)

static task_del(id: int) → int

Calls function rz_core_task_del (defined in task.c)

static task_enqueue(task: RzCoreTask) → None

Calls function rz_core_task_enqueue (defined in task.c)

static task_enqueue_oneshot(func: RzCoreTaskOneShot, user: Any) → None

Calls function rz_core_task_enqueue_oneshot (defined in task.c)

static task_get_incref(id: int) → RzCoreTask

Calls function rz_core_task_get_incref (defined in task.c)

static task_incref() → None

Calls function rz_core_task_incref (defined in task.c)

static task_join(current: RzCoreTask, id: int) → None

Calls function rz_core_task_join (defined in task.c)

static task_new(runner: RzCoreTaskRunner, runner_free: RzCoreTaskRunnerFree, runner_user: Any) → RzCoreTask

Calls function rz_core_task_new (defined in task.c)

static task_run_sync(task: RzCoreTask) → int

Calls function rz_core_task_run_sync (defined in task.c)

static task_running_tasks_count() → int

Calls function rz_core_task_running_tasks_count (defined in task.c)

static task_scheduler_fini() → None

Calls function rz_core_task_scheduler_fini (defined in task.c)

static task_scheduler_init(ctx_switch: RzCoreTaskContextSwitch, ctx_switch_user: Any, break_cb: RzCoreTaskBreak, break_cb_user: Any) → None

Calls function rz_core_task_scheduler_init (defined in task.c)

static task_self() → RzCoreTask

Calls function rz_core_task_self (defined in task.c)

static task_sleep_begin() → None

Calls function rz_core_task_sleep_begin (defined in task.c)

static task_sleep_end() → None

Calls function rz_core_task_sleep_end (defined in task.c)

static task_status() → str

Calls function rz_core_task_status (defined in task.c)

static task_sync_begin() → None

Calls function rz_core_task_sync_begin (defined in task.c)

static task_sync_end() → None

Calls function rz_core_task_sync_end (defined in task.c)

static task_yield() → None

Calls function rz_core_task_yield (defined in task.c)

static visual_append_help(title: str, help: Pointer[Pointer[int]]) → None

Calls function rz_core_visual_append_help (defined in visual.c)

add_asmqjmp(addr: int) → str

Calls function rz_core_add_asmqjmp (defined in core.c)

Takes addr and returns already saved shortcut or a new one The returned buffer needs to be freed

agraph_print(use_utf: int, input: str) → None

Calls function rz_core_agraph_print (defined in cmd_analysis.c)

analysis_address(addr: int) → int

Calls function rz_core_analysis_address (defined in canalysis.c)

analysis_all() → int

Calls function rz_core_analysis_all (defined in canalysis.c)

analysis_autoname_all_fcns() → None

Calls function rz_core_analysis_autoname_all_fcns (defined in canalysis.c)

analysis_bytes(buf: int, len: int, nops: int) → RzPVector[RzAnalysisBytes]

Calls function rz_core_analysis_bytes (defined in canalysis.c)

Analyze and disassemble bytes use rz_analysis_op and rz_asm_disassemble

Parameters:

• core – The RzCore instance

• buf – data to analysis

• len – analysis len bytes

• nops – analysis n ops

Returns:

list of RzAnalysisBytes

analysis_callgraph(addr: int, fmt: int) → None

Calls function rz_core_analysis_callgraph (defined in canalysis.c)

analysis_calls(imports_only: bool) → None

Calls function rz_core_analysis_calls (defined in cmd_analysis.c)

analysis_calls_count() → int

Calls function rz_core_analysis_calls_count (defined in canalysis.c)

Compute analysis function xrefs count.

analysis_cc_init() → None

Calls function rz_core_analysis_cc_init (defined in canalysis.c)

analysis_code_count() → int

Calls function rz_core_analysis_code_count (defined in canalysis.c)

Compute analysis code count.

analysis_coderefs(addr: int) → None

Calls function rz_core_analysis_coderefs (defined in canalysis.c)

analysis_codexrefs(addr: int) → RzGraph

Calls function rz_core_analysis_codexrefs (defined in canalysis.c)

analysis_continue_until_call() → bool

Calls function rz_core_analysis_continue_until_call (defined in canalysis.c)

Continue until call.

Parameters:

core – The RzCore instance

Returns:

success

analysis_continue_until_syscall() → bool

Calls function rz_core_analysis_continue_until_syscall (defined in canalysis.c)

Continue until syscall.

Parameters:

core – The RzCore instance

Returns:

success

analysis_coverage_count() → int

Calls function rz_core_analysis_coverage_count (defined in canalysis.c)

Compute analysis coverage count.

analysis_cycles(ccl: int) → RzList[RzAnalysisCycleHook]

Calls function rz_core_analysis_cycles (defined in canalysis.c)

analysis_data(addr: int, count: int, depth: int, wordsize: int) → int

Calls function rz_core_analysis_data (defined in canalysis.c)

analysis_datarefs(addr: int) → None

Calls function rz_core_analysis_datarefs (defined in canalysis.c)

analysis_esil(addr: int, size: int, fcn: RzAnalysisFunction) → None

Calls function rz_core_analysis_esil (defined in canalysis.c)

Analyze references with esil (aae)

addr start address size number of bytes to analyze fcn optional, when analyzing for a specific function

analysis_esil_deinit() → None

Calls function rz_core_analysis_esil_deinit (defined in cil.c)

Deinitialize ESIL.

Parameters:

core – RzCore reference

analysis_esil_init_mem(name: str, addr: int, size: int) → None

Calls function rz_core_analysis_esil_init_mem (defined in cil.c)

Initialize ESIL memory stack region.

Parameters:

• core – RzCore reference

• name – Optional name of the memory stack region. If NULL, a name is computed automatically based on addr and size

• addr – Base address of the stack region, if UT64_MAX it is automatically computed

• size – Size of the stack region, if UT32_MAX it is automatically computed

analysis_esil_init_mem_del(name: str, addr: int, size: int) → None

Calls function rz_core_analysis_esil_init_mem_del (defined in cil.c)

Remove ESIL VM stack.

Parameters:

• core – RzCore reference

• name – Optional name of the memory stack region. If NULL, a name is computed automatically based on addr and size

• addr – Base address of the stack region, if UT64_MAX it is automatically computed

• size – Size of the stack region, if UT32_MAX it is automatically computed

analysis_esil_init_regs() → None

Calls function rz_core_analysis_esil_init_regs (defined in cil.c)

Initialize ESIL registers.

Parameters:

core – RzCore reference

analysis_esil_reinit() → None

Calls function rz_core_analysis_esil_reinit (defined in cil.c)

Reinitialize ESIL.

Parameters:

core – RzCore reference

analysis_esil_step_over() → None

Calls function rz_core_analysis_esil_step_over (defined in cil.c)

analysis_esil_trace_start() → bool

Calls function rz_core_analysis_esil_trace_start (defined in canalysis.c)

Start ESIL trace session.

Parameters:

core – The RzCore instance

Returns:

false when an error occurs otherwise true

analysis_esil_trace_stop() → bool

Calls function rz_core_analysis_esil_trace_stop (defined in canalysis.c)

Stop ESIL trace session.

Parameters:

core – The RzCore instance

Returns:

false when an error occurs otherwise true

analysis_everything(experimental: bool, dh_orig: str) → bool

Calls function rz_core_analysis_everything (defined in canalysis.c)

Runs all the steps of the deep analysis.

Returns true if all steps were finished and false if it was interrupted.

Parameters:

• core – RzCore reference

• experimental – Enable more experimental analysis stages (“aaaa” command)

• dh_orig – Name of the debug handler, e.g. “esil”

analysis_fcn(at: int, from: int, reftype: int, depth: int) → int

Calls function rz_core_analysis_fcn (defined in canalysis.c)

analysis_fcn_clean(addr: int) → int

Calls function rz_core_analysis_fcn_clean (defined in canalysis.c)

analysis_fcn_get_calls(fcn: RzAnalysisFunction) → RzList[RzAnalysisXRef]

Calls function rz_core_analysis_fcn_get_calls (defined in canalysis.c)

analysis_fcn_merge(addr: int, addr2: int) → None

Calls function rz_core_analysis_fcn_merge (defined in canalysis.c)

analysis_fcn_name(fcn: RzAnalysisFunction) → str

Calls function rz_core_analysis_fcn_name (defined in canalysis.c)

analysis_flag_every_function() → None

Calls function rz_core_analysis_flag_every_function (defined in canalysis.c)

analysis_function_add(name: str, addr: int, analyze_recursively: bool) → bool

Calls function rz_core_analysis_function_add (defined in canalysis.c)

analysis_function_autoname(fcn: RzAnalysisFunction) → str

Calls function rz_core_analysis_function_autoname (defined in canalysis.c)

Suggest a name for the function.

analysis_function_rename(addr: int, _name: str) → bool

Calls function rz_core_analysis_function_rename (defined in canalysis.c)

analysis_function_strings_print(fcn: RzAnalysisFunction, pj: PJ) → None

Calls function rz_core_analysis_function_strings_print (defined in canalysis.c)

Print all string flags referenced by the function.

analysis_get_comments(addr: int) → str

Calls function rz_core_analysis_get_comments (defined in core.c)

analysis_get_stats(from: int, to: int, step: int) → RzCoreAnalysisStats

Calls function rz_core_analysis_get_stats (defined in canalysis.c)

Generate statistics for a range of memory, e.g. for a colorful overview bar.

Let fullsz = to + 1 - from. If fullsz % step = 0, then the result will be fullsz / step blocks of size step. Otherwise, it will be fullsz / step blocks of size step and one additional block covering the rest.

Parameters:

• lowest – address to consider

• highest – address to consider, inclusive. Must be greater than or equal to from.

• size – of a single block in the output

analysis_graph(addr: int, opts: int) → bool

Calls function rz_core_analysis_graph (defined in canalysis.c)

analysis_graph_to(addr: int, n: int) → RzList[RzAnalysisBlock]

Calls function rz_core_analysis_graph_to (defined in canalysis.c)

analysis_hasrefs(value: int, mode: int) → str

Calls function rz_core_analysis_hasrefs (defined in core.c)

analysis_hasrefs_to_depth(value: int, pj: PJ, depth: int) → str

Calls function rz_core_analysis_hasrefs_to_depth (defined in core.c)

analysis_hint_set_offset(struct_member: str) → bool

Calls function rz_core_analysis_hint_set_offset (defined in canalysis.c)

Set analysis hint for the first immediate of the instruction at current offset to struct_member.

Parameters:

• core – The RzCore instance

• struct_member – struct.member

analysis_importxrefs() → RzGraph

Calls function rz_core_analysis_importxrefs (defined in canalysis.c)

analysis_name(addr: int) → RzCoreAnalysisName

Calls function rz_core_analysis_name (defined in canalysis.c)

Get information on whatever var/flag/function is used at addr.

Returns:

RzAnalysisName

analysis_op(addr: int, mask: int) → RzAnalysisOp

Calls function rz_core_analysis_op (defined in canalysis.c)

analysis_optype_colorfor(addr: int, verbose: bool) → str

Calls function rz_core_analysis_optype_colorfor (defined in core.c)

analysis_paths(from: int, to: int, followCalls: bool, followDepth: int, is_json: bool) → None

Calls function rz_core_analysis_paths (defined in canalysis.c)

analysis_propagate_noreturn(addr: int) → None

Calls function rz_core_analysis_propagate_noreturn (defined in canalysis.c)

analysis_recover_golang_functions() → bool

Calls function rz_core_analysis_recover_golang_functions (defined in golang.c)

reads pclntab table in go binaries and recovers functions. Follows the code https://github.com/golang/go/blob/master/src/debug/gosym/pclntab.go#L188

Parameters:

core – The RzCore to use

Returns:

Returns true when 1 or more symbols have been recovered.

analysis_refs(nbytes: size_t) → bool

Calls function rz_core_analysis_refs (defined in canalysis.c)

Analyze xrefs and prints the result.

Parameters:

• core – The RzCore to use

• nbytes – Sets a custom boundary from current offset for N bytes (set it to 0 to use the maps)

Returns:

False on failure, otherwise true

analysis_rename(name: str, addr: int) → bool

Calls function rz_core_analysis_rename (defined in canalysis.c)

Rename whatever var/flag/function is used at addr to name.

Returns:

success?

analysis_resolve_golang_strings() → None

Calls function rz_core_analysis_resolve_golang_strings (defined in golang.c)

Attempts to recover all golang string.

Parameters:

core – The RzCore struct to use

analysis_resolve_jumps() → None

Calls function rz_core_analysis_resolve_jumps (defined in canalysis.c)

Resolves any unresolved jump.

Parameters:

core – The RzCore to use

analysis_search(from: int, to: int, ref: int, mode: int) → int

Calls function rz_core_analysis_search (defined in canalysis.c)

analysis_search_xrefs(from: int, to: int) → int

Calls function rz_core_analysis_search_xrefs (defined in canalysis.c)

Searches for xrefs in the range of the paramters 'from' and 'to'.

Parameters:

• core – The Rizin core.

• from – Start of search interval.

• to – End of search interval.

Returns:

int Number of found xrefs. -1 in case of failure.

analysis_sigdb_apply(n_applied: int, filter: str) → bool

Calls function rz_core_analysis_sigdb_apply (defined in canalysis.c)

tries to apply the signatures in the flirt.sigdb.path

Parameters:

• core – The RzCore instance

• n_applied – Returns the number of successfully applied signatures

• filter – Filters the signatures found following the user input

Returns:

fail when an error occurs otherwise true

analysis_sigdb_list(with_details: bool) → RzList[RzSigDBEntry]

Calls function rz_core_analysis_sigdb_list (defined in canalysis.c)

Returns all the signatures found in the default path.

Scans for signature in the following paths:

• home path + RZ_SIGDB

• system install prefix path + RZ_SIGDB

• flirt.sigdb.path user custom sigdb path

Parameters:

• core – The RzCore to use.

• with_details – The reads the signature details and sets them in RzSigDBEntry

Returns:

On success a RzList containing RzSigDBEntry entries, otherwise NULL.

analysis_sigdb_print(table: RzTable) → None

Calls function rz_core_analysis_sigdb_print (defined in canalysis.c)

Adds all the signatures to a RzTable structure.

Parameters:

• core – The RzCore to use

• table – The RzTable to use

analysis_type_init() → None

Calls function rz_core_analysis_type_init (defined in canalysis.c)

analysis_type_match(fcn: RzAnalysisFunction, addr_loop_table: HtUU) → None

Calls function rz_core_analysis_type_match (defined in analysis_tp.c)

analysis_undefine(off: int) → None

Calls function rz_core_analysis_undefine (defined in canalysis.c)

arch_bits_at(addr: int, bits: int, arch: Pointer[Pointer[int]]) → None

Calls function rz_core_arch_bits_at (defined in cio.c)

arg_get(cc: str, num: int) → int

Warning

Calls deprecated function rz_core_arg_get

Calls function rz_core_arg_get (defined in carg.c)

Get the value of the num-th argument from the current debug or emulation state.

Warning: this function contains hacks. Rewrite it before using it in new code.

asm_back_disassemble_byte(addr: int, len: int, hit_count: int, extra_padding: int) → RzList[RzCoreAsmHit]

Calls function rz_core_asm_back_disassemble_byte (defined in casm.c)

asm_back_disassemble_instr(addr: int, len: int, hit_count: int, extra_padding: int) → RzList[RzCoreAsmHit]

Calls function rz_core_asm_back_disassemble_instr (defined in casm.c)

asm_bwdis_len(len: int, start_addr: int, l: int) → int

Calls function rz_core_asm_bwdis_len (defined in casm.c)

asm_bwdisassemble(addr: int, n: int, len: int) → RzList[RzCoreAsmHit]

Calls function rz_core_asm_bwdisassemble (defined in casm.c)

asm_plugins_print(arch: str, state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_asm_plugins_print (defined in casm.c)

asm_search(input: str) → str

Calls function rz_core_asm_search (defined in casm.c)

asm_strsearch(input: str, from: int, to: int, maxhits: int, regexp: int, everyByte: int, mode: int) → RzList[RzCoreAsmHit]

Calls function rz_core_asm_strsearch (defined in casm.c)

assembly_of_hex(hex: int, len: int) → str

Calls function rz_core_assembly_of_hex (defined in cprint.c)

Get the assembly of the hexstr.

Parameters:

• core – RzCore

• hex – hex

• len – length of hex

Returns:

a string containing the assembly of the hexstr

autocomplete(completion: RzLineCompletion, buf: RzLineBuffer, prompt_type: RzLinePromptType) → None

Calls function rz_core_autocomplete (defined in core.c)

autocomplete_reload() → None

Calls function rz_core_autocomplete_reload (defined in core.c)

autocomplete_rzshell(buf: RzLineBuffer, prompt_type: RzLinePromptType) → RzLineNSCompletionResult

Calls function rz_core_autocomplete_rzshell (defined in cautocmpl.c)

Returns a RzLineNSCompletionResult structure containing all the info to autocomplete what is currently in buf.

bb_starts_in_middle(at: int, oplen: int) → int

Calls function rz_core_bb_starts_in_middle (defined in disasm.c)

bin_apply_all_info(binfile: RzBinFile) → bool

Calls function rz_core_bin_apply_all_info (defined in cbin.c)

bin_apply_classes(binfile: RzBinFile) → bool

Calls function rz_core_bin_apply_classes (defined in cbin.c)

bin_apply_config(binfile: RzBinFile) → bool

Calls function rz_core_bin_apply_config (defined in cbin.c)

bin_apply_dwarf(binfile: RzBinFile) → bool

Calls function rz_core_bin_apply_dwarf (defined in cbin.c)

bin_apply_entry(binfile: RzBinFile, va: bool) → bool

Calls function rz_core_bin_apply_entry (defined in cbin.c)

bin_apply_imports(binfile: RzBinFile, va: bool) → bool

Calls function rz_core_bin_apply_imports (defined in cbin.c)

bin_apply_info(binfile: RzBinFile, mask: int) → bool

Calls function rz_core_bin_apply_info (defined in cbin.c)

bin_apply_main(binfile: RzBinFile, va: bool) → bool

Calls function rz_core_bin_apply_main (defined in cbin.c)

bin_apply_maps(binfile: RzBinFile, va: bool) → bool

Calls function rz_core_bin_apply_maps (defined in cbin.c)

bin_apply_relocs(binfile: RzBinFile, va: bool) → bool

Calls function rz_core_bin_apply_relocs (defined in cbin.c)

bin_apply_resources(binfile: RzBinFile) → bool

Calls function rz_core_bin_apply_resources (defined in cbin.c)

bin_apply_sections(binfile: RzBinFile, va: bool) → bool

Calls function rz_core_bin_apply_sections (defined in cbin.c)

bin_apply_strings(binfile: RzBinFile) → bool

Calls function rz_core_bin_apply_strings (defined in cbin.c)

bin_apply_symbols(binfile: RzBinFile, va: bool) → bool

Calls function rz_core_bin_apply_symbols (defined in cbin.c)

bin_basefind_print(pointer_size: int, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_basefind_print (defined in cbin.c)

bin_class_as_source_print(bf: RzBinFile, class_name: str) → bool

Calls function rz_core_bin_class_as_source_print (defined in cbin.c)

bin_class_fields_print(bf: RzBinFile, state: RzCmdStateOutput, class_name: str) → bool

Calls function rz_core_bin_class_fields_print (defined in cbin.c)

bin_class_methods_print(bf: RzBinFile, state: RzCmdStateOutput, class_name: str) → bool

Calls function rz_core_bin_class_methods_print (defined in cbin.c)

bin_classes_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_classes_print (defined in cbin.c)

bin_create_digests(paddr: int, size: int, digests: RzList[char]) → HtPP

Calls function rz_core_bin_create_digests (defined in cbin.c)

Create a hashtable of digests.

Digest names are supplied as a list of char * strings. Returns the hashtable with keys of digest names and values of strings containing requested digests.

bin_cur_export_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_cur_export_print (defined in cbin.c)

bin_cur_section_print(bf: RzBinFile, state: RzCmdStateOutput, hashes: RzList[char]) → bool

Calls function rz_core_bin_cur_section_print (defined in cbin.c)

bin_cur_segment_print(bf: RzBinFile, state: RzCmdStateOutput, hashes: RzList[char]) → bool

Calls function rz_core_bin_cur_segment_print (defined in cbin.c)

bin_cur_symbol_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_cur_symbol_print (defined in cbin.c)

bin_dwarf_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_dwarf_print (defined in cbin.c)

bin_entries_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_entries_print (defined in cbin.c)

bin_export_info(mode: int) → None

Calls function rz_core_bin_export_info (defined in cbin.c)

bin_exports_print(bf: RzBinFile, state: RzCmdStateOutput, filter: RzCoreBinFilter) → bool

Calls function rz_core_bin_exports_print (defined in cbin.c)

bin_fields_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_fields_print (defined in cbin.c)

bin_headers_print(bf: RzBinFile) → bool

Calls function rz_core_bin_headers_print (defined in cbin.c)

bin_imports_print(bf: RzBinFile, state: RzCmdStateOutput, filter: RzCoreBinFilter) → bool

Calls function rz_core_bin_imports_print (defined in cbin.c)

bin_info_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_info_print (defined in cbin.c)

bin_initfini_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_initfini_print (defined in cbin.c)

bin_libs_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_libs_print (defined in cbin.c)

bin_load(file_uri: str, base_addr: int) → bool

Calls function rz_core_bin_load (defined in cfile.c)

bin_load_structs(file: str) → bool

Calls function rz_core_bin_load_structs (defined in cbin.c)

bin_main_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_main_print (defined in cbin.c)

bin_memory_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_memory_print (defined in cbin.c)

bin_options_init(opts: RzBinOptions, fd: int, baseaddr: int, loadaddr: int) → None

Calls function rz_core_bin_options_init (defined in cbin.c)

bin_pdb_get_filename() → str

Calls function rz_core_bin_pdb_get_filename (defined in cbin.c)

bin_pdb_load(filename: str) → bool

Calls function rz_core_bin_pdb_load (defined in cbin.c)

bin_print(bf: RzBinFile, mask: int, filter: RzCoreBinFilter, state: RzCmdStateOutput, hashes: RzList[char]) → bool

Calls function rz_core_bin_print (defined in cbin.c)

Print (to RzCons or inside RzCmdStateOutput) the binary information specified in mask.

This function can be used to print information from the current binary file. What type of information to print depends on the value of mask, which can be a mix of RZ_CORE_BIN_ACC_ defines. When filter is NULL, all informations are printed. When filter is not NULL some information (e.g. symbols, sections, imports, etc.) are filtered by name and/or address.

The argument state is used to specify the output mode you want the info.

Parameters:

• core – RzCore instance

• bf – RzBinFile to consider

• mask – Mask of info you want to print, see RZ_CORE_BIN_ACC_ defines

• filter – When specified it filter some of the info by name and/or address

• state – RzCmdStateOutput instance specifying the output mode

• hashes – List of strings with name of hashes that RZ_CORE_BIN_ACC_SECTIONS/SEGMENTS should print

Returns:

true if everything that was requested was printed well, false otherwise

bin_print_source_line_info(li: RzBinSourceLineInfo, state: RzCmdStateOutput) → None

Calls function rz_core_bin_print_source_line_info (defined in cbin.c)

bin_print_source_line_sample(s: RzBinSourceLineSample, state: RzCmdStateOutput) → None

Calls function rz_core_bin_print_source_line_sample (defined in cbin.c)

bin_raise(bfid: int) → bool

Calls function rz_core_bin_raise (defined in cbin.c)

bin_rebase(baddr: int) → int

Calls function rz_core_bin_rebase (defined in cfile.c)

bin_relocs_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_relocs_print (defined in cbin.c)

bin_resources_print(bf: RzBinFile, state: RzCmdStateOutput, hashes: RzList[char]) → bool

Calls function rz_core_bin_resources_print (defined in cbin.c)

bin_sections_mapping_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_sections_mapping_print (defined in cbin.c)

bin_sections_print(bf: RzBinFile, state: RzCmdStateOutput, filter: RzCoreBinFilter, hashes: RzList[char]) → bool

Calls function rz_core_bin_sections_print (defined in cbin.c)

bin_segments_print(bf: RzBinFile, state: RzCmdStateOutput, filter: RzCoreBinFilter, hashes: RzList[char]) → bool

Calls function rz_core_bin_segments_print (defined in cbin.c)

bin_set_arch_bits(name: str, arch: str, bits: int) → int

Calls function rz_core_bin_set_arch_bits (defined in cbin.c)

bin_set_by_fd(bin_fd: int) → int

Calls function rz_core_bin_set_by_fd (defined in cbin.c)

bin_set_by_name(name: str) → int

Calls function rz_core_bin_set_by_name (defined in cbin.c)

bin_set_cur(binfile: RzBinFile) → bool

Calls function rz_core_bin_set_cur (defined in cbin.c)

Set binfile as current binfile.

Parameters:

• core – The RzCore instance

• binfile – RzBinFile, it will find by current fd if NULL

Returns:

Success?

bin_signatures_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_signatures_print (defined in cbin.c)

bin_size_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_size_print (defined in cbin.c)

bin_strings_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_strings_print (defined in cbin.c)

bin_symbols_print(bf: RzBinFile, state: RzCmdStateOutput, filter: RzCoreBinFilter) → bool

Calls function rz_core_bin_symbols_print (defined in cbin.c)

bin_trycatch_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_trycatch_print (defined in cbin.c)

bin_update_arch_bits() → int

Calls function rz_core_bin_update_arch_bits (defined in cbin.c)

bin_versions_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_versions_print (defined in cbin.c)

bin_whole_strings(bf: RzBinFile) → RzList[RzBinString]

Calls function rz_core_bin_whole_strings (defined in cbin.c)

bin_whole_strings_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_bin_whole_strings_print (defined in cbin.c)

bind(bnd: RzCoreBind) → int

Calls function rz_core_bind (defined in core.c)

bind_cons() → None

Calls function rz_core_bind_cons (defined in core.c)

binfiles_delete(bf: RzBinFile) → bool

Calls function rz_core_binfiles_delete (defined in cbin.c)

Close an opened binary file.

Parameters:

• core – Reference to RzCore instance

• bf – Reference to RzBinFile to delete

Returns:

true if the file was closed, false otherwise

binfiles_print(state: RzCmdStateOutput) → bool

Calls function rz_core_binfiles_print (defined in cbin.c)

Print all the opened binary files according to state.

Parameters:

• core – Reference to RzCore instance

• state – Reference to RzCmdStateOutput containing all the data to print data in the right format

Returns:

true if everything was alright, false otherwise

block_read() → int

Calls function rz_core_block_read (defined in cio.c)

block_size(bsize: int) → bool

Calls function rz_core_block_size (defined in core.c)

clippy(msg: str) → None

Calls function rz_core_clippy (defined in cmd_help.c)

cmd(cmd: str, log: int) → int

Calls function rz_core_cmd (defined in cmd.c)

cmd0(cmd: str) → int

Calls function rz_core_cmd0 (defined in cmd.c)

cmd0_rzshell(cmd: str) → RzCmdStatus

Calls function rz_core_cmd0_rzshell (defined in cmd.c)

cmd_buffer(buf: str) → int

Calls function rz_core_cmd_buffer (defined in cmd.c)

cmd_command(command: str) → int

Calls function rz_core_cmd_command (defined in cmd.c)

cmd_file(file: str) → int

Calls function rz_core_cmd_file (defined in cmd.c)

cmd_foreach(cmd: str, each: str) → int

Calls function rz_core_cmd_foreach (defined in cmd.c)

cmd_foreach3(cmd: str, each: str) → int

Calls function rz_core_cmd_foreach3 (defined in cmd.c)

cmd_help(help: Pointer[Pointer[int]]) → None

Calls function rz_core_cmd_help (defined in cmd.c)

cmd_init() → None

Calls function rz_core_cmd_init (defined in cmd.c)

cmd_lines(lines: str) → int

Calls function rz_core_cmd_lines (defined in cmd.c)

cmd_lines_rzshell(lines: str) → RzCmdStatus

Calls function rz_core_cmd_lines_rzshell (defined in cmd.c)

cmd_pipe_old(rizin_cmd: str, shell_cmd: str) → int

Calls function rz_core_cmd_pipe_old (defined in cmd.c)

cmd_raw(cmd: str, length: int) → int

Calls function rz_core_cmd_raw (defined in cmd.c)

Executes a rizin command and returns the raw stdout and its length.

cmd_rzshell(cmd: str, log: int) → RzCmdStatus

Calls function rz_core_cmd_rzshell (defined in cmd.c)

cmd_str(cmd: str) → str

Calls function rz_core_cmd_str (defined in cmd.c)

Executes a rizin command and returns the stdout as a string.

cmd_str_pipe(cmd: str) → str

Calls function rz_core_cmd_str_pipe (defined in cmd.c)

cmd_task_new(cmd: str, finished_cb: RzCoreCmdTaskFinished, finished_cb_user: Any) → RzCoreTask

Calls function rz_core_cmd_task_new (defined in task.c)

Create a new task that runs a command and saves its result. These tasks are user-visible under the & command family.

config_in_space(space: str) → RzList[char]

Calls function rz_core_config_in_space (defined in cconfig.c)

Get config variable spaces.

Parameters:

• core – The RzCore instance

• space – The config space

Returns:

RzList of config variable spaces

config_init() → int

Calls function rz_core_config_init (defined in cconfig.c)

core_plugins_print(state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_core_plugins_print (defined in core.c)

dbg_follow_seek_register() → None

Calls function rz_core_dbg_follow_seek_register (defined in cmd_debug.c)

Seek to PC if needed.

Parameters:

core – The RzCore instance

debug_backtraces() → RzList[RzBacktrace]

Calls function rz_core_debug_backtraces (defined in cdebug.c)

Get backtraces based on dbg.btdepth and dbg.btalgo.

Parameters:

core – The RzCore instance

Returns:

A list of RzBacktrace

debug_bp_add_noreturn_func() → None

Calls function rz_core_debug_bp_add_noreturn_func (defined in cdebug.c)

Put a breakpoint into every no-return function.

Parameters:

core – Current RzCore instance

Returns:

void

debug_breakpoint_toggle(addr: int) → None

Calls function rz_core_debug_breakpoint_toggle (defined in cdebug.c)

Toggle breakpoint.

Parameters:

• core – RzCore instance

• addr – Breakpoint addr

debug_clear_register_flags() → None

Calls function rz_core_debug_clear_register_flags (defined in cmd_debug.c)

debug_continue_until(addr: int, to: int) → bool

Calls function rz_core_debug_continue_until (defined in cdebug.c)

debug_map_print(addr: int, state: RzCmdStateOutput) → None

Calls function rz_core_debug_map_print (defined in cdebug.c)

debug_map_update_flags() → None

Calls function rz_core_debug_map_update_flags (defined in cdebug.c)

Create or update flags for all current debug maps in the “maps” flagspace

debug_plugins_print(state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_debug_plugins_print (defined in cdebug.c)

debug_process_close() → bool

Calls function rz_core_debug_process_close (defined in cdebug.c)

Close debug process (Kill debugee and all child processes)

Parameters:

core – The RzCore instance

Returns:

success

debug_ri() → None

Calls function rz_core_debug_ri (defined in cmd_debug.c)

debug_set_register_flags() → None

Calls function rz_core_debug_set_register_flags (defined in cmd_debug.c)

debug_step_back(steps: int) → bool

Calls function rz_core_debug_step_back (defined in cdebug.c)

Step back.

Parameters:

• core – The RzCore instance

• steps – Step steps

Returns:

success

debug_step_one(times: int) → bool

Calls function rz_core_debug_step_one (defined in cdebug.c)

debug_step_over(steps: int) → bool

Calls function rz_core_debug_step_over (defined in cdebug.c)

Step over.

Parameters:

• core – The RzCore instance

• steps – Step steps

debug_step_skip(times: int) → bool

Calls function rz_core_debug_step_skip (defined in cdebug.c)

Skip operations.

Parameters:

• core – The RzCore instance

• times – Skip op times

debug_step_until_frame() → bool

Calls function rz_core_debug_step_until_frame (defined in cdebug.c)

Step until end of frame.

Parameters:

core – The RzCore instance

Returns:

success

diff_show(core2: RzCore, json: bool) → None

Calls function rz_core_diff_show (defined in gdiff.c)

diff_show_function(core2: RzCore, addr: int, json: bool) → bool

Calls function rz_core_diff_show_function (defined in gdiff.c)

Generate a json or dot output of the graph and its data.

Each node that doesn’t match 100% with the other function will include a unified diff of the assembly of the same basic block.

disasm_instruction(addr: int, reladdr: int, fcn: RzAnalysisFunction, color: bool) → str

Calls function rz_core_disasm_instruction (defined in disasm.c)

Returns a disassembly of one instruction.

It returns disassembly on one instruction with additional output changes: function local variables subsitution, PC-relative addressing subsitution, analysis hints affecting the disassembly output, optional colors.

Parameters:

• core – RzCore instance

• addr – An address of the instruction

• reladdr – An address to substitute PC-relative expressions in disasm (asm.sub.rel config)

• fcn – A function where the instruction located for local variables substitution (optional)

• color – To toggle color escape sequences in the output

disasm_pde(nb_opcodes: int, state: RzCmdStateOutput) → int

Calls function rz_core_disasm_pde (defined in disasm.c)

disasm_pdi(nb_opcodes: int, nb_bytes: int, fmt: int) → int

Calls function rz_core_disasm_pdi (defined in disasm.c)

disasm_pdi_with_buf(address: int, buf: int, nb_opcodes: int, nb_bytes: int, fmt: int) → int

Calls function rz_core_disasm_pdi_with_buf (defined in disasm.c)

disassemble_bytes(addr: int, b: int) → str

Calls function rz_core_disassemble_bytes (defined in cmd.c)

disassemble_instr(addr: int, l: int) → str

Calls function rz_core_disassemble_instr (defined in cmd.c)

dump(file: str, addr: int, size: int, append: int) → bool

Calls function rz_core_dump (defined in cio.c)

editor(file: str, str: str) → str

Calls function rz_core_editor (defined in core.c)

esil_continue_back() → bool

Calls function rz_core_esil_continue_back (defined in cmd_analysis.c)

esil_of_assembly(assembly: str) → str

Calls function rz_core_esil_of_assembly (defined in cprint.c)

Get the esil of the assembly.

Parameters:

• core – RzCore

• assembly – assembly

Returns:

a string containing the esil of the assembly

esil_of_hex(hex: int, len: int) → str

Calls function rz_core_esil_of_hex (defined in cprint.c)

Get the esil of the hexstr.

Parameters:

• core – RzCore

• hex – hex

• len – length of hex

Returns:

a string containing the esil of the hexstr

esil_step(until_addr: int, until_expr: str, prev_addr: int, stepOver: bool) → int

Calls function rz_core_esil_step (defined in cmd_analysis.c)

esil_step_back() → int

Calls function rz_core_esil_step_back (defined in cmd_analysis.c)

extend_at(addr: int, size: int) → bool

Calls function rz_core_extend_at (defined in cio.c)

Extend the file at current offset by inserting size 0 bytes at addr.

addr is an physical/virtual address based on the value of eval “io.va”. When virtual it is translated to a physical address according to the IO map at the current offset

Parameters:

• core – Reference to RzCore instance

• addr – Address where to insert new 0 bytes.

• size – Number of 0 bytes to insert

Returns:

true if extend operation was successful, false otherwise

file_bin_raise(num: int) → bool

Calls function rz_core_file_bin_raise (defined in cfile.c)

file_binlist() → int

Calls function rz_core_file_binlist (defined in cfile.c)

file_close_all_but() → bool

Calls function rz_core_file_close_all_but (defined in cfile.c)

file_close_fd(fd: int) → bool

Calls function rz_core_file_close_fd (defined in cfile.c)

file_cur() → RzCoreFile

Calls function rz_core_file_cur (defined in cfile.c)

file_cur_fd() → int

Calls function rz_core_file_cur_fd (defined in cfile.c)

file_find_by_fd(fd: int) → RzCoreFile

Calls function rz_core_file_find_by_fd (defined in cfile.c)

file_find_by_name(name: str) → RzCoreFile

Calls function rz_core_file_find_by_name (defined in cfile.c)

file_get_by_fd(fd: int) → RzCoreFile

Calls function rz_core_file_get_by_fd (defined in cfile.c)

file_info_print(bf: RzBinFile, state: RzCmdStateOutput) → bool

Calls function rz_core_file_info_print (defined in cbin.c)

file_open(file: str, flags: int, loadaddr: int) → RzCoreFile

Calls function rz_core_file_open (defined in cfile.c)

Tries to open the file as is, otherwise tries as is a compilation of files.

Calls rz_io_open_nomap but if it fails, then tries with rz_core_file_open_many; Also, loadaddr is rizin -m (mapaddr)

file_open_load(filepath: str, addr: int, perms: int, write_mode: bool) → bool

Calls function rz_core_file_open_load (defined in cfile.c)

Tries to open the file, load binary info and make RzIOMap.

Returns:

Success?

file_open_many(file: str, perm: int, loadaddr: int) → RzCoreFile

Calls function rz_core_file_open_many (defined in cfile.c)

Open the file as a compilation of files.

Calls rz_io_open_many and maps all the file descriptors to an RzCoreFile

file_print(mode: RzOutputMode) → bool

Calls function rz_core_file_print (defined in cfile.c)

file_reopen(args: str, perm: int, binload: int) → bool

Calls function rz_core_file_reopen (defined in cfile.c)

file_reopen_debug(args: str) → None

Calls function rz_core_file_reopen_debug (defined in cfile.c)

file_reopen_remote_debug(uri: str, addr: int) → None

Calls function rz_core_file_reopen_remote_debug (defined in cfile.c)

file_resize(newsize: int) → bool

Calls function rz_core_file_resize (defined in cfile.c)

file_resize_delta(delta: int) → bool

Calls function rz_core_file_resize_delta (defined in cfile.c)

file_set_by_fd(fd: int) → int

Calls function rz_core_file_set_by_fd (defined in cfile.c)

file_set_by_file(cf: RzCoreFile) → int

Calls function rz_core_file_set_by_file (defined in cfile.c)

file_set_by_name(name: str) → int

Calls function rz_core_file_set_by_name (defined in cfile.c)

fini() → None

Calls function rz_core_fini (defined in core.c)

flag_in_middle(at: int, oplen: int, midflags: int) → int

Calls function rz_core_flag_in_middle (defined in disasm.c)

flirt_convert_file(input_file: str, ouput_file: str) → bool

Calls function rz_core_flirt_convert_file (defined in csign.c)

converts a FLIRT file to the other format.

Parameters:

• input_file – Input file

• output_file – Output file

• optimize – Optimization value (expects an RZ_FLIRT_NODE_OPTIMIZE_* value)

Returns:

true on success, false on failure

flirt_create_file(output_file: str, written_nodes: int) → bool

Calls function rz_core_flirt_create_file (defined in csign.c)

Generates a new FLIRT file from a given RzCore structure.

Parameters:

• core – RzCore to use.

• output_file – Output file.

• written_nodes – When not NULL, returns the number of nodes written in the file.

Returns:

true on success, false on failure

flush(cmd: str) → int

Calls function rz_core_flush (defined in cmd.c)

fortune_get_random() → str

Calls function rz_core_fortune_get_random (defined in fortune.c)

fortune_list() → None

Calls function rz_core_fortune_list (defined in fortune.c)

fortune_print_random() → None

Calls function rz_core_fortune_print_random (defined in fortune.c)

function_task_new(fcn: RzCoreTaskFunction, fcn_user: Any) → RzCoreTask

Calls function rz_core_function_task_new (defined in task.c)

Create a new task that runs a custom function and saves its result. These tasks are not user-visible.

gadget_print() → None

Calls function rz_core_gadget_print (defined in cmd_print.c)

Prints or displays the print gadgets while in visual mode.

Parameters:

core – reference to RzCore

gdiff_2_files(core2: RzCore) → bool

Calls function rz_core_gdiff_2_files (defined in gdiff.c)

Calculates basic block differences of all functions within 2 files.

Calculates basic block differences of all functions within 2 files.

gdiff_function_1_file(addr: int, addr2: int) → bool

Calls function rz_core_gdiff_function_1_file (defined in gdiff.c)

Calculates basic block differences of 2 functions within the same file.

Calculates basic block differences of 2 functions within the same file

gdiff_function_2_files(core2: RzCore, addr: int, addr2: int) → bool

Calls function rz_core_gdiff_function_2_files (defined in gdiff.c)

Calculates basic block differences of 2 functions within 2 files.

Calculates basic block differences of 2 functions within 2 files

get_asmqjmps(str: str) → int

Calls function rz_core_get_asmqjmps (defined in core.c)

get_bin() → RzBin

Calls function rz_core_get_bin (defined in core.c)

get_boundaries_prot(protection: int, mode: str, prefix: str) → RzList[RzIOMap]

Calls function rz_core_get_boundaries_prot (defined in cmd_search.c)

get_config() → RzConfig

Calls function rz_core_get_config (defined in core.c)

get_cons() → RzCons

Calls function rz_core_get_cons (defined in core.c)

get_func_args(func_name: str) → RzList[RzAnalysisFuncArg]

Calls function rz_core_get_func_args (defined in carg.c)

get_reloc_to(addr: int) → RzBinReloc

Calls function rz_core_get_reloc_to (defined in core.c)

get_section_name(addr: int) → str

Calls function rz_core_get_section_name (defined in disasm.c)

get_stacksz(from: int, to: int) → int

Calls function rz_core_get_stacksz (defined in canalysis.c)

getreloc(addr: int, size: int) → RzBinReloc

Calls function rz_core_getreloc (defined in core.c)

hack(op: str) → bool

Calls function rz_core_hack (defined in hack.c)

Write/Modify instructions at current offset based on op.

See specific functions rz_core_hack_<arch> for what they accept as op .

Parameters:

• core – RzCore instance

• op – A string representing one of the operation that can be performed on the current offset

Returns:

true if the write was done correctly, false otherwise

hack_help() → None

Calls function rz_core_hack_help (defined in hack.c)

help_vars_get() → Pointer[Pointer[int]]

Calls function rz_core_help_vars_get (defined in cmd_help.c)

Returns all the $ variable names in a NULL-terminated array.

help_vars_print() → None

Calls function rz_core_help_vars_print (defined in cmd_help.c)

hex_of_assembly(assembly: str) → str

Calls function rz_core_hex_of_assembly (defined in cprint.c)

Get the hexpair of the assembly.

Parameters:

• core – RzCore

• assembly – assembly

Returns:

a string containing the hexpair of the assembly

init() → bool

Calls function rz_core_init (defined in core.c)

io_cache_print(state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_io_cache_print (defined in cio.c)

io_file_open(fd: int) → None

Calls function rz_core_io_file_open (defined in cfile.c)

Open file use read-only Permission.

Parameters:

• core – RzCore instance

• fd – File descriptor

io_file_reopen(fd: int, perms: int) → None

Calls function rz_core_io_file_reopen (defined in cfile.c)

Reopen file.

Parameters:

• core – RzCore instance

• fd – File descriptor

• perms – Permission s RZ_PERM_R

io_pcache_print(desc: RzIODesc, state: RzCmdStateOutput) → RzCmdStatus

Calls function rz_core_io_pcache_print (defined in cio.c)

is_debug() → bool

Calls function rz_core_is_debug (defined in cdebug.c)

Check whether the core is in debug mode (equivalent to cfg.debug)

is_valid_offset(offset: int) → int

Calls function rz_core_is_valid_offset (defined in cio.c)

link_stroff(fcn: RzAnalysisFunction) → None

Calls function rz_core_link_stroff (defined in ctypes.c)

loadlibs(where: int) → int

Calls function rz_core_loadlibs (defined in libs.c)

loadlibs_init() → None

Calls function rz_core_loadlibs_init (defined in libs.c)

meta_pascal_string_add(addr: int, encoding: RzStrEnc, name: str) → bool

Calls function rz_core_meta_pascal_string_add (defined in cmeta.c)

add a pascal string to RzCore

Parameters:

• core – RzCore of core that will be add to

• addr – string’s address

• size – string’s max size

• encoding – string’s encoding

• name – string’s value, or null that will be autodetect at addr

Returns:

is add successful?

meta_string_add(addr: int, size: int, encoding: RzStrEnc, name: str) → bool

Calls function rz_core_meta_string_add (defined in cmeta.c)

add a string to RzCore

Parameters:

• core – RzCore of core that will be add to

• addr – string’s address

• size – string’s max size

• encoding – string’s encoding

• name – string’s value, or null that will be autodetect at addr

Returns:

is add successful?

op_analysis(addr: int, mask: RzAnalysisOpMask) → RzAnalysisOp

Calls function rz_core_op_analysis (defined in core.c)

op_str(addr: int) → str

Calls function rz_core_op_str (defined in core.c)

parse_rizinrc() → None

Calls function rz_core_parse_rizinrc (defined in cconfig.c)

pava(addr: int) → int

Calls function rz_core_pava (defined in disasm.c)

pdb_info_print(db: RzTypeDB, pdb: RzPdb, state: RzCmdStateOutput) → None

Calls function rz_core_pdb_info_print (defined in cpdb.c)

Print parsed PDB file info.

Parameters:

• db – RzTypeDB

• pdb – instance of PDB

• state – Output State

Returns:

void

pdb_load_info(file: str) → RzPdb

Calls function rz_core_pdb_load_info (defined in cpdb.c)

Parse PDB file info and integrate with typedb.

Parameters:

• core – RzCore instance

• file – Path of PDB file

Returns:

bool

plugin_add(plugin: RzCorePlugin) → bool

Calls function rz_core_plugin_add (defined in cplugin.c)

plugin_fini() → bool

Calls function rz_core_plugin_fini (defined in cplugin.c)

plugin_init() → bool

Calls function rz_core_plugin_init (defined in cplugin.c)

prevop_addr(start_addr: int, numinstrs: int, prev_addr: int) → bool

Calls function rz_core_prevop_addr (defined in visual.c)

prevop_addr_force(start_addr: int, numinstrs: int) → int

Calls function rz_core_prevop_addr_force (defined in visual.c)

print_bb_custom(fcn: RzAnalysisFunction) → int

Calls function rz_core_print_bb_custom (defined in canalysis.c)

print_bb_gml(fcn: RzAnalysisFunction) → int

Calls function rz_core_print_bb_gml (defined in canalysis.c)

print_disasm(addr: int, buf: int, len: int, nlines: int, state: RzCmdStateOutput, options: RzCoreDisasmOptions) → int

Calls function rz_core_print_disasm (defined in disasm.c)

Disassemble len bytes and nlines opcodes restricted by len and nlines at the same time.

Parameters:

• core – RzCore reference

• addr – Address

• buf – Buffer

• len – Bytes number

• nlines – Opcode number

• options – Disassemble Options

Returns:

Disassemble bytes number

print_disasm_all(addr: int, l: int, len: int, mode: int) → int

Calls function rz_core_print_disasm_all (defined in disasm.c)

print_disasm_instructions(nb_bytes: int, nb_opcodes: int) → int

Calls function rz_core_print_disasm_instructions (defined in disasm.c)

print_disasm_instructions_with_buf(address: int, buf: int, nb_bytes: int, nb_opcodes: int) → int

Calls function rz_core_print_disasm_instructions_with_buf (defined in disasm.c)

print_disasm_json(addr: int, buf: int, len: int, lines: int, pj: PJ) → int

Calls function rz_core_print_disasm_json (defined in disasm.c)

print_dump_str(mode: RzOutputMode, addr: int, n: int, len: int, format: RzCorePrintFormatType) → str

Calls function rz_core_print_dump_str (defined in cprint.c)

Print dump at addr.

Parameters:

• n – Word size by bytes (1,2,4,8)

• len – Dump bytes length

• format – Print format, such as RZ_CORE_PRINT_FORMAT_TYPE_HEXADECIMAL

print_func_args() → None

Calls function rz_core_print_func_args (defined in carg.c)

print_function_disasm_json(fcn: RzAnalysisFunction, pj: PJ) → bool

Calls function rz_core_print_function_disasm_json (defined in disasm.c)

print_hexdump_byline_str(hex_offset: bool, addr: int, len: int, size: int) → str

Calls function rz_core_print_hexdump_byline_str (defined in cprint.c)

Hexdump at addr.

Parameters:

• len – Dump bytes length

• size – Word size by bytes (1,2,4,8)

Returns:

Hexdump string

print_hexdump_diff_str(aa: int, ba: int, len: int) → str

Calls function rz_core_print_hexdump_diff_str (defined in cprint.c)

Print hexdump diff between aa and ba with len.

print_hexdump_or_hexdiff_str(mode: RzOutputMode, addr: int, len: int, use_comment: bool) → str

Calls function rz_core_print_hexdump_or_hexdiff_str (defined in cprint.c)

Print hexdump at addr, but maybe print hexdiff if (diff.from or diff.to),.

Parameters:

len – Dump bytes length

print_scrollbar() → None

Calls function rz_core_print_scrollbar (defined in visual.c)

print_scrollbar_bottom() → None

Calls function rz_core_print_scrollbar_bottom (defined in visual.c)

print_string_c_cpp() → str

Calls function rz_core_print_string_c_cpp (defined in cprint.c)

Return a C/C++ string defination with block size as the length

Parameters:

core – RzCore

Returns:

a string defination or NULL if the error happens

project_load_for_cli(file: str, load_bin_io: bool) → bool

Calls function rz_core_project_load_for_cli (defined in cmd_project.c)

prompt(sync: int) → int

Calls function rz_core_prompt (defined in core.c)

prompt_exec() → int

Calls function rz_core_prompt_exec (defined in core.c)

prompt_loop() → None

Calls function rz_core_prompt_loop (defined in core.c)

raw_file_print() → bool

Calls function rz_core_raw_file_print (defined in cfile.c)

recover_vars(fcn: RzAnalysisFunction, argonly: bool) → None

Calls function rz_core_recover_vars (defined in canalysis.c)

reg_assign_sync(reg: RzReg, sync_cb: RzCmdRegSync, name: str, val: int) → bool

Calls function rz_core_reg_assign_sync (defined in cmd_regs.c)

Register assignment like reg=0x42

Parameters:

• core – The RzCore instance

• reg – The RzReg instance

• sync_cb – Callback for synchronizing register state in command

• name – Register name

• val – Value

Returns:

success

reg_default() → RzReg

Calls function rz_core_reg_default (defined in creg.c)

Get the currently relevant RzReg.

Depending on whether or not the core is in debug mode, this returns the RzReg from debug or analysis (emulation). Before using this function, think twice whether it would not make more sense to use core->dbg->reg or analysis->dbg->reg directly, depending on what you want to do with it.

reg_filter_items_sync(reg: RzReg, sync_cb: RzCmdRegSync, filter: str) → RzList[RzRegItem]

Calls function rz_core_reg_filter_items_sync (defined in cmd_regs.c)

Filter a list of RzRegItem and sync read

Parameters:

• core – The RzCore instance

• reg – The RzReg instance

• sync_cb – Callback for synchronizing register state in command

• filter – Filter registers

Returns:

List of RzRegItem

reg_getv_by_role_or_name(name: str) → int

Calls function rz_core_reg_getv_by_role_or_name (defined in creg.c)

rz_reg_getv_by_role_or_name() on rz_core_reg_default()

reg_set_by_role_or_name(name: str, num: int) → bool

Calls function rz_core_reg_set_by_role_or_name (defined in creg.c)

set on rz_core_reg_default()

This also makes sure that, in debug mode, registers are synced, and updates flags if there are any.

reg_update_flags() → None

Calls function rz_core_reg_update_flags (defined in creg.c)

Update or create flags for all registers where it makes sense.

Registers are taken either from rz_core_reg_default(). “makes sens” currently means regs that have the same size as an address, but this may change in case a better heuristic is found.

rtr_add(input: str) → None

Calls function rz_core_rtr_add (defined in rtr.c)

rtr_cmd(input: str) → None

Calls function rz_core_rtr_cmd (defined in rtr.c)

rtr_cmds(port: str) → int

Calls function rz_core_rtr_cmds (defined in rtr.c)

rtr_cmds_query(host: str, port: str, cmd: str) → str

Calls function rz_core_rtr_cmds_query (defined in rtr.c)

rtr_gdb(launch: int, path: str) → int

Calls function rz_core_rtr_gdb (defined in rtr.c)

rtr_http(launch: int, browse: int, path: str) → int

Calls function rz_core_rtr_http (defined in rtr_http.c)

rtr_http_stop() → int

Calls function rz_core_rtr_http_stop (defined in rtr.c)

rtr_init() → bool

Calls function rz_core_rtr_init (defined in rtr.c)

Allocates core rtr structure.

Parameters:

core – RzCore to initialize rtr structure

rtr_list() → None

Calls function rz_core_rtr_list (defined in rtr.c)

rtr_pushout(input: str) → None

Calls function rz_core_rtr_pushout (defined in rtr.c)

rtr_remove(input: str) → None

Calls function rz_core_rtr_remove (defined in rtr.c)

rtr_session(input: str) → None

Calls function rz_core_rtr_session (defined in rtr.c)

run_script(file: str) → bool

Calls function rz_core_run_script (defined in cmd.c)

search_cb(from: int, to: int, cb: RzCoreSearchCallback) → int

Calls function rz_core_search_cb (defined in core.c)

search_prelude(from: int, to: int, buf: int, blen: int, mask: int, mlen: int) → int

Calls function rz_core_search_prelude (defined in cmd_search.c)

search_preludes(log: bool) → int

Calls function rz_core_search_preludes (defined in cmd_search.c)

search_value_in_range(search_itv: RzInterval, vmin: int, vmax: int, vsize: int, cb: inRangeCb, cb_user: Any) → int

Calls function rz_core_search_value_in_range (defined in canalysis.c)

seek(addr: int, rb: bool) → bool

Calls function rz_core_seek (defined in seek.c)

Seek to addr.

Parameters:

• core – RzCore reference

• addr – Address where to move to

• rb – If true read the block

seek_align(align: int, save: bool) → bool

Calls function rz_core_seek_align (defined in seek.c)

Seek to current offset aligned to align.

Parameters:

• core – RzCore reference

• align – Value to align the current offset

• save – If true save the current state in seek history before seeking

seek_analysis_bb(addr: int, save: bool) → bool

Calls function rz_core_seek_analysis_bb (defined in seek.c)

Seek to basic block that contains address addr.

Parameters:

• core – RzCore reference

• addr – Address that needs to be in the basicblock

• save – If true save the current state in seek history before seeking

seek_and_save(addr: int, rb: bool) → bool

Calls function rz_core_seek_and_save (defined in seek.c)

Save currently marked state in seek history and seek to addr .

If rz_core_seek_mark is used to mark a position, that position will be saved in the history, otherwise the current state is used.

Parameters:

• core – RzCore reference

• addr – Address where to move to

• rb – If true read the block

seek_arch_bits(addr: int) → None

Calls function rz_core_seek_arch_bits (defined in cio.c)

seek_base(hex: str, save: bool) → int

Calls function rz_core_seek_base (defined in seek.c)

Seek to a new address composed of current offset with last hex digits replaced with those of hex.

Parameters:

• core – RzCore reference

• hex – New final part of the address (in hex)

• save – If true save the current state in seek history before seeking

seek_delta(delta: int, save: bool) → bool

Calls function rz_core_seek_delta (defined in seek.c)

Seek relative to current offset and optionally save the current offset in seek history.

Parameters:

• core – RzCore reference

• delta – Delta address added to the current offset

• save – If true save the current state in seek history before seeking

seek_free() → None

Calls function rz_core_seek_free (defined in seek.c)

Free seek history data

seek_list() → RzList[RzCoreSeekItem]

Calls function rz_core_seek_list (defined in seek.c)

Return the seek history.

The list is composed of some items with negative idx which are Undos items (potentially none), then there is an item with is_current=true that is the current state, followed by some items with positive idx which are Redos items.

seek_mark() → bool

Calls function rz_core_seek_mark (defined in seek.c)

Mark current state (offset+cursor) as the next state to save in history.

The saving can be disabled if eval var cfg.seek.silent is set to true. The state saved here is actually saved in history once rz_core_seek_and_save is called (or other functions with the save argument set to true).

Parameters:

core – RzCore reference

seek_next(type: str, save: bool) → bool

Calls function rz_core_seek_next (defined in seek.c)

Seek to the next type of item from current offset.

Parameters:

• core – RzCore reference

• type – Type of next “item” to seek to (could be “opc”, “fun”, “hit”, “flag”)

• save – If true save the current state in seek history before seeking

seek_opt(addr: int, read_block: bool, save: bool) → bool

Calls function rz_core_seek_opt (defined in seek.c)

Seek to addr and optionally save the current offset in seek history.

Parameters:

• core – RzCore reference

• addr – Address where to move to

• rb – If true read the block

• save – If true save the current state in seek history before seeking

seek_peek(idx: int) → RzCoreSeekItem

Calls function rz_core_seek_peek (defined in seek.c)

Return a element in the undo/redo list.

The element is not removed from the list nor it is restored as the current state. Useful if you want to inspect the undo history. The object shall be freed by the caller.

Parameters:

• core – Reference to RzCore

• idx – Index of the element. 0 references the current seek, <0 are undos, >0 redos

seek_prev(type: str, save: bool) → bool

Calls function rz_core_seek_prev (defined in seek.c)

Seek to the previous type of item from current offset.

Parameters:

• core – RzCore reference

• type – Type of previous “item” to seek to (could be “opc”, “fun”, “hit”, “flag”)

• save – If true save the current state in seek history before seeking

seek_redo() → bool

Calls function rz_core_seek_redo (defined in seek.c)

Redo the last undone entry in the seek history

seek_reset() → None

Calls function rz_core_seek_reset (defined in seek.c)

Remove all seek history entries

seek_save() → bool

Calls function rz_core_seek_save (defined in seek.c)

Save last marked position, if any, in the seek history.

Parameters:

core – RzCore reference

seek_undo() → bool

Calls function rz_core_seek_undo (defined in seek.c)

Undo the last entry in the seek history

serve(fd: RzIODesc) → bool

Calls function rz_core_serve (defined in core.c)

set_asm_configs(arch: str, bits: int, segoff: int) → None

Calls function rz_core_set_asm_configs (defined in cmd_print.c)

set_asmqjmps(str: str, len: size_t, i: int) → None

Calls function rz_core_set_asmqjmps (defined in core.c)

setup_debugger(debugbackend: str, attach: bool) → int

Calls function rz_core_setup_debugger (defined in cio.c)

shift_block(addr: int, b_size: int, dist: int) → bool

Calls function rz_core_shift_block (defined in cio.c)

Shift a block of data from addr of size b_size left or right based on dist.

Parameters:

• core – Reference to RzCore instance

• addr – Address of the block of data to move

• b_size – Size of the block of data to move

• dist – Where to shift the data, whether backward or forward and how distant from the original position

Returns:

true if the shift operation was succesful, false otherwise

sym_name_init(sn: RzBinSymNames, sym: RzBinSymbol, lang: str) → None

Calls function rz_core_sym_name_init (defined in cbin.c)

Initlize sn.

Parameters:

• r – The RzCore instance

• sn – The RzBinSymNames to output

• sym – Symbol info

• lang – Language info

syscall(name: str, args: str) → RzBuffer

Calls function rz_core_syscall (defined in core.c)

syscall_as_string(num: int, addr: int) → str

Calls function rz_core_syscall_as_string (defined in csyscall.c)

Returns the syscall representation as a string.

Given the syscall number and address it resolves the syscall for the selected asm.arch and asm.os values and print its arguments.

The number of the syscall can also be -1 to try to read the value of the syscall from the register that is the syscall number by the selected calling convention.

Parameters:

• core – RzCore instance

• n – number of the syscall

• addr – address of the syscall

sysenv_begin() → None

Calls function rz_core_sysenv_begin (defined in cfile.c)

sysenv_end() → None

Calls function rz_core_sysenv_end (defined in cfile.c)

table() → RzTable

Calls function rz_core_table (defined in core.c)

task_del_all_done() → None

Calls function rz_core_task_del_all_done (defined in task.c)

task_is_cmd(id: int) → bool

Calls function rz_core_task_is_cmd (defined in task.c)

task_list(mode: int) → None

Calls function rz_core_task_list (defined in task.c)

task_print(task: RzCoreTask, mode: int, j: PJ) → None

Calls function rz_core_task_print (defined in task.c)

theme_get() → str

Calls function rz_core_theme_get (defined in cmd_eval.c)

theme_list() → RzList[char]

Calls function rz_core_theme_list (defined in cmd_eval.c)

Returns the list of the rizin themes.

Parameters:

core – The RzCore struct to use

Returns:

On success, an RzList pointer, otherwise NULL.

theme_load(name: str) → bool

Calls function rz_core_theme_load (defined in cmd_eval.c)

theme_nextpal(mode: RzConsPalSeekMode) → None

Calls function rz_core_theme_nextpal (defined in cmd_eval.c)

transform_op(addr: int, op: RzCoreWriteOp, hex: int, hexlen: int, buflen: int) → int

Calls function rz_core_transform_op (defined in cio.c)

Transform a block of data at addr according to the operation op and the hexvalue hex.

Parameters:

• core – Reference to RzCore instance

• addr – Where the block of data to modify starts

• op – Operation to perform on the block of data

• hex – Optional hex string that may be required by the specific operation

• hexlen – Optional length of the hex string. Must be present if hex is specified.

• buflen – Used to return the length of the returned buffer

Returns:

The transformed buffer

types_as_c(name: str, multiline: bool) → str

Calls function rz_core_types_as_c (defined in ctypes.c)

Get a type string by name (.

Parameters:

• core – RzCore reference

• name – Type name

• multiline – Pretty printing with RZ_TYPE_PRINT_MULTILINE

types_as_c_all(multiline: bool) → str

Calls function rz_core_types_as_c_all (defined in ctypes.c)

Get all types with pretty printing.

Parameters:

• core – RzCore reference

• multiline – Pretty printing with RZ_TYPE_PRINT_MULTILINE

types_link(typestr: str, addr: int) → None

Calls function rz_core_types_link (defined in ctypes.c)

Link an address addr to the type referenced by typestr.

NOTE: This is likely going to be deprecated with the use of global variables.

Parameters:

• core – RzCore reference

• typestr – Name of the type that should be defined at addr

• addr – Address where the type should be used

visual(input: str) → int

Calls function rz_core_visual (defined in visual.c)

visual_analysis(input: str) → None

Calls function rz_core_visual_analysis (defined in vmenus.c)

visual_analysis_classes() → int

Calls function rz_core_visual_analysis_classes (defined in vmenus.c)

visual_applyDisMode(disMode: int) → None

Calls function rz_core_visual_applyDisMode (defined in visual.c)

visual_applyHexMode(hexMode: int) → None

Calls function rz_core_visual_applyHexMode (defined in visual.c)

visual_asm(addr: int) → None

Calls function rz_core_visual_asm (defined in vasm.c)

visual_bit_editor() → bool

Calls function rz_core_visual_bit_editor (defined in vmenus.c)

visual_browse(arg: str) → None

Calls function rz_core_visual_browse (defined in visual.c)

visual_classes() → int

Calls function rz_core_visual_classes (defined in vmenus.c)

visual_cmd(arg: str) → int

Calls function rz_core_visual_cmd (defined in visual.c)

visual_colors() → None

Calls function rz_core_visual_colors (defined in vmenus.c)

visual_comments() → int

Calls function rz_core_visual_comments (defined in vmenus.c)

visual_config() → None

Calls function rz_core_visual_config (defined in vmenus.c)

visual_debugtraces(input: str) → None

Calls function rz_core_visual_debugtraces (defined in vmenus.c)

visual_define(arg: str, distance: int) → None

Calls function rz_core_visual_define (defined in vmenus.c)

visual_disasm_down(op: RzAsmOp, cols: int) → None

Calls function rz_core_visual_disasm_down (defined in visual.c)

visual_disasm_up(cols: int) → None

Calls function rz_core_visual_disasm_up (defined in visual.c)

visual_esil() → bool

Calls function rz_core_visual_esil (defined in vmenus.c)

visual_graph(g: RzAGraph, _fcn: RzAnalysisFunction, is_interactive: int) → int

Calls function rz_core_visual_graph (defined in agraph.c)

visual_hud() → bool

Calls function rz_core_visual_hud (defined in visual.c)

visual_hudstuff() → bool

Calls function rz_core_visual_hudstuff (defined in vmenus.c)

visual_jump(ch: int) → None

Calls function rz_core_visual_jump (defined in visual.c)

visual_mark(ch: int) → None

Calls function rz_core_visual_mark (defined in vmarks.c)

visual_mark_del(ch: int) → None

Calls function rz_core_visual_mark_del (defined in vmarks.c)

visual_mark_dump() → bool

Calls function rz_core_visual_mark_dump (defined in vmarks.c)

visual_mark_reset() → None

Calls function rz_core_visual_mark_reset (defined in vmarks.c)

visual_mark_seek(ch: int) → None

Calls function rz_core_visual_mark_seek (defined in vmarks.c)

visual_mark_set(ch: int, addr: int) → None

Calls function rz_core_visual_mark_set (defined in vmarks.c)

visual_offset() → None

Calls function rz_core_visual_offset (defined in visual.c)

visual_panels_root(panels_root: RzPanelsRoot) → bool

Calls function rz_core_visual_panels_root (defined in panels.c)

visual_prevopsz(addr: int) → int

Calls function rz_core_visual_prevopsz (defined in visual.c)

visual_prompt() → int

Calls function rz_core_visual_prompt (defined in visual.c)

visual_prompt_input() → None

Calls function rz_core_visual_prompt_input (defined in visual.c)

visual_seek_animation(addr: int) → None

Calls function rz_core_visual_seek_animation (defined in visual.c)

visual_seek_animation_redo() → None

Calls function rz_core_visual_seek_animation_redo (defined in visual.c)

visual_seek_animation_undo() → None

Calls function rz_core_visual_seek_animation_undo (defined in visual.c)

visual_showcursor(x: int) → None

Calls function rz_core_visual_showcursor (defined in visual.c)

visual_toggle_decompiler_disasm(for_graph: bool, reset: bool) → None

Calls function rz_core_visual_toggle_decompiler_disasm (defined in visual.c)

visual_toggle_hints() → None

Calls function rz_core_visual_toggle_hints (defined in visual.c)

visual_trackflags() → int

Calls function rz_core_visual_trackflags (defined in vmenus.c)

visual_view_graph() → int

Calls function rz_core_visual_view_graph (defined in vmenus_graph.c)

visual_view_rop() → int

Calls function rz_core_visual_view_rop (defined in vmenus.c)

visual_xrefs(xref_to: bool, fcnInsteadOfAddr: bool) → int

Calls function rz_core_visual_xrefs (defined in visual.c)

wait() → None

Calls function rz_core_wait (defined in rtr.c)

write_assembly(addr: int, instructions: str) → int

Calls function rz_core_write_assembly (defined in cio.c)

Assembles instructions and writes the resulting data at the given offset.

Parameters:

• core – RzCore reference

• addr – Address to where to write

• instructions – List of instructions to assemble as a string

Returns:

Returns the length of the written data or -1 in case of error

write_assembly_fill(addr: int, instructions: str) → int

Calls function rz_core_write_assembly_fill (defined in cio.c)

Assemble instructions and write the resulting data inside the current instruction.

Assemble one or more instructions and write the resulting data inside the current instruction, if the new instructions fit. Fill the rest of the bytes of the old instruction with NOP

Parameters:

• core – RzCore reference

• addr – Address to where to write

• instructions – List of instructions to assemble as a string

Returns:

Returns the length of the written data or -1 in case of error (e.g. the new instruction does not fit)

write_at(addr: int, buf: int, size: int) → bool

Calls function rz_core_write_at (defined in cio.c)

write_base64_at(addr: int, s: str) → bool

Calls function rz_core_write_base64_at (defined in cio.c)

Write a given string s at the specified addr encoded as base64.

Parameters:

• core – RzCore reference

• addr – Address where to write the string

• s – String to encode as base64 and then written.

write_base64d_at(addr: int, s: str) → bool

Calls function rz_core_write_base64d_at (defined in cio.c)

Write a given base64 string s at the specified addr, decoded.

Parameters:

• core – RzCore reference

• addr – Address where to write the string

• s – String to decode from base64 and then written

write_block(addr: int, data: int, len: size_t) → bool

Calls function rz_core_write_block (defined in cio.c)

Writes the bytes data at address addr cyclically until it fills the whole block

It repeats the data data with length len until it fills an entire block starting at addr.

Parameters:

• core – RzCore reference

• addr – Address to where to write

• data – Array of bytes to cyclically write in the block at addr

• len – Length of data

write_block_op_at(addr: int, op: RzCoreWriteOp, hex: int, hexlen: int) → bool

Calls function rz_core_write_block_op_at (defined in cio.c)

Write a full block of data according to the operation op and the hexvalue hex.

Parameters:

• core – Reference to RzCore instance

• addr – Where the block of data to modify starts

• op – Operation to perform on the block of data

• hex – Optional hex string that may be required by the specific operation

• hexlen – Optional length of the hex string. Must be present if hex is specified.

Returns:

true if the write operation succeeds, false otherwise

write_duplicate_at(addr: int, from: int, len: int) → bool

Calls function rz_core_write_duplicate_at (defined in cio.c)

Copy len bytes from from to addr.

Parameters:

• core – Reference to RzCore instance

• addr – Where the data should be copied to

• from – Where the data should be read from

• len – Number of bytes to copy, expected to not be negative

Returns:

true if the write operation succeeds, false otherwise

write_hexpair(addr: int, pairs: str) → int

Calls function rz_core_write_hexpair (defined in cio.c)

Writes the hexadecimal string at the given offset

Returns the length of the written data.

Parameters:

• core – RzCore reference

• addr – Address to where to write

• pairs – Data as the hexadecimal string

write_length_string_at(addr: int, s: str) → bool

Calls function rz_core_write_length_string_at (defined in cio.c)

Write at the specified addr the length of the string in one byte, followed by the given string s.

Parameters:

• core – RzCore reference

• addr – Address where to write the string

• s – String to write. The string is unescaped, meaning that if there is \n it becomes 0x0a

write_random_at(addr: int, len: size_t) → bool

Calls function rz_core_write_random_at (defined in cio.c)

Write len random bytes at address addr.

Parameters:

• core – RzCore reference

• addr – Address where to write the data

• len – Length of the random data to write

write_seq_at(addr: int, from: int, to: int, step: int, value_size: int) → bool

Calls function rz_core_write_seq_at (defined in cio.c)

Write a full block of data with a sequence.

Write a full block of data with a sequence of numbers starting from from up to to, with a step of step. The values are written as numbers of value_size bytes.

Parameters:

• core – Reference to RzCore instance

• addr – Where the block of data to modify starts

• from – From where to start the sequence of numbers

• to – Where to stop in the sequence

• step – Difference between two numbers in the sequence

• value_size – Size of each number of the sequence, in bytes

Returns:

true if the write operation succeeds, false otherwise

write_string_at(addr: int, s: str) → bool

Calls function rz_core_write_string_at (defined in cio.c)

Write a given string s at the specified addr.

Parameters:

• core – RzCore reference

• addr – Address where to write the string

• s – String to write. The string is unescaped, meaning that if there is \n it becomes 0x0a

write_string_wide_at(addr: int, s: str) → bool

Calls function rz_core_write_string_wide_at (defined in cio.c)

Write a given string s as a wide string at the specified addr.

Parameters:

• core – RzCore reference

• addr – Address where to write the string

• s – String to write. The string is unescaped, meaning that if there is \n it becomes 0x0a

write_string_zero_at(addr: int, s: str) → bool

Calls function rz_core_write_string_zero_at (defined in cio.c)

Write a given string s, followed by the zero terminator, at the specified addr.

Parameters:

• core – RzCore reference

• addr – Address where to write the string

• s – String to write. The string is unescaped, meaning that if there is \n it becomes 0x0a

write_value_at(addr: int, value: int, sz: int) → bool

Calls function rz_core_write_value_at (defined in cio.c)

Write a given value at the specified address, using sz bytes.

Parameters:

• core – RzCore reference

• addr – Address where to write the value

• value – Value to write

• sz – Number of bytes to write. Can be 1, 2, 4, 8 or the special value 0 if you want the function to choose based on value (4 if value is <4GB, 8 otherwise)

write_value_inc_at(addr: int, value: int, sz: int) → bool

Calls function rz_core_write_value_inc_at (defined in cio.c)

Write at addr the current value + value passed as argument.

The values read/written are considered as integers of sz bytes.

Parameters:

• core – RzCore reference

• addr – Address where to overwrite the value

• value – Value to sum to the existing value in addr

• sz – Size of the values, in bytes, to consider. Can be 1, 2, 4, 8.

yank(addr: int, len: int) → bool

Calls function rz_core_yank (defined in yank.c)

yank_as_string(pos: int) → str

Calls function rz_core_yank_as_string (defined in yank.c)

yank_dump(pos: int, state: RzCmdStateOutput) → bool

Calls function rz_core_yank_dump (defined in yank.c)

yank_file(len: int, addr: int, filename: str) → bool

Calls function rz_core_yank_file (defined in yank.c)

yank_file_all(filename: str) → bool

Calls function rz_core_yank_file_all (defined in yank.c)

yank_hexpair(str: str) → bool

Calls function rz_core_yank_hexpair (defined in yank.c)

yank_hud_file(input: str) → bool

Calls function rz_core_yank_hud_file (defined in yank.c)

yank_hud_path(input: str, dir: int) → bool

Calls function rz_core_yank_hud_path (defined in yank.c)

yank_paste(addr: int, len: int) → bool

Calls function rz_core_yank_paste (defined in yank.c)

yank_print(pos: int) → bool

Calls function rz_core_yank_print (defined in yank.c)

yank_print_hexdump(pos: int) → bool

Calls function rz_core_yank_print_hexdump (defined in yank.c)

yank_print_string(pos: int) → bool

Calls function rz_core_yank_print_string (defined in yank.c)

yank_set(addr: int, buf: int, len: int) → bool

Calls function rz_core_yank_set (defined in yank.c)

yank_set_str(addr: int, str: str) → bool

Calls function rz_core_yank_set_str (defined in yank.c)

yank_string(addr: int, maxlen: int) → bool

Calls function rz_core_yank_string (defined in yank.c)

yank_to(len: int, addr: int) → bool

Calls function rz_core_yank_to (defined in yank.c)