ida-mcp-rs MCP Server: Headless IDA Pro for Reverse Engineering with Claude, Cursor and Codex

• Turns a function into C-like code you can read

  Uses the Hex-Rays decompiler to produce pseudocode for one or more functions, picked by address or name. It needs a decompiler license for the processor of the file you are analyzing.

  Try: “Decompile the function at 0x100003f50 and explain what it does.”

  Read · decompile

• Lists the functions IDA found, with sizes

  Returns function names, addresses and sizes a page at a time. You can filter by part of a name to narrow a big binary down.

  Try: “List the first 50 functions whose name contains "crypt".”

  Read · list_functions

• Finds the address of a function by name

  Looks up an exact or demangled function name and returns its address and size. Use it before decompiling or disassembling something you only know by name.

  Try: “What is the address of the function called main?”

  Read · resolve_function

• Tells you which function contains an address

  Given any address, such as one taken from a crash log, returns the function around it with its start, end and size.

  Try: “Which function contains the address 0x1000a2b4c?”

  Read · function_at

• Looks up many function names at once

  Takes a list of names and returns the address and size of each one found, in a single call instead of one call per name.

  Try: “Find the addresses of malloc, free, memcpy and strcpy in this binary.”

  Read · lookup_funcs

• Lists the text strings stored in the binary

  Returns every string IDA found with its address, a page at a time. A filter narrows it to strings containing some text, which helps spot URLs, file paths and error messages.

  Try: “Show me strings that look like URLs or file paths.”

  Read · strings

• Finds strings that match a search

  Searches the found strings for a substring or an exact match and returns the matching addresses. Results come back in pages.

  Try: “Find any string mentioning "password".”

  Read · find_string

• Filters strings for patterns such as URLs or paths

  Lists strings with an optional substring filter and paging. It overlaps with strings and suits pulling out one kind of text from a large list.

  Try: “List strings that contain "http" so I can see the network endpoints.”

  Read · analyze_strings

• Shows everything that points at an address

  Finds all code and data that reference an address. It is the quick way to see who calls a function or who reads a variable.

  Try: “Show every place that references the function at 0x100004a10.”

  Read · xrefs_to

• Shows what an address points to

  Lists what a given instruction or data item refers to, such as the functions it calls or the data it reads.

  Try: “What does the instruction at 0x100004a10 reference?”

  Read · xrefs_from

• Finds code that uses a given string

  Searches for strings matching your text and returns the places in code that reference each match. It answers "where is this message used".

  Try: “Which functions use the string "license check failed"?”

  Read · xrefs_to_string

• Finds code that touches one struct field

  Lists references to a named member of a struct, by struct name or number and member name or index.

  Try: “Find all code that accesses the "flags" field of struct Session.”

  Read · xrefs_to_field

• Maps which addresses reference each other

  Takes several addresses and returns a table of true or false showing which ones reference which others.

  Try: “Show how the five functions at these addresses reference each other.”

  Read · xref_matrix

• Lists the functions that call a function

  Returns the names and addresses of everything that calls the function you give it.

  Try: “Who calls the function named decrypt_config?”

  Read · callers

• Lists the functions a function calls

  Returns the names and addresses of every function called by the function you give it. Good for a quick idea of what a routine depends on.

  Try: “What does main call?”

  Read · callees

• Draws a call tree from one or more functions

  Builds a graph of calls starting at a function, downward to callees, upward to callers, or both. It flags when a node limit cut the graph short.

  Try: “Build a call graph two levels deep below the function handle_request.”

  Read · callgraph

• Breaks a function into its code blocks

  Returns the control-flow blocks of a function with their sizes and which block leads to which.

  Try: “Show the basic blocks of the function at 0x100003f50.”

  Read · basic_blocks

• Finds routes between two points in a function

  Lists the control-flow paths from one address to another inside the same function, up to a depth limit. Both addresses must be in one function.

  Try: “Find the paths from the function entry to the call at 0x100004120.”

  Read · find_paths

• Shows assembly instructions from an address

  Disassembles a number of instructions starting at an address and returns addresses, opcodes and text.

  Try: “Disassemble 30 instructions at 0x100003f50.”

  Read · disasm

• Shows the assembly for a named function

  Resolves a function name to its address and disassembles from there.

  Try: “Show the assembly for the function named parse_header.”

  Read · disasm_by_name

• Shows the assembly for the function around an address

  Disassembles the whole function that contains the address you give. Handy when all you have is a program counter value.

  Try: “Disassemble the function that contains 0x1000a2b4c.”

  Read · disasm_function_at

• Prints an address range as IDA would show it

  Returns IDA's own disassembly text for a bounded range, including data definitions as well as code, with a marker for continuing if it was cut short.

  Try: “Render the listing from 0x100010000 to 0x100010100.”

  Read · render_range

• Shows decompiled code for just one spot

  Returns only the pseudocode statements that belong to an address or range, such as one code block, rather than the whole function.

  Try: “Show the decompiled statements for the block at 0x100004120.”

  Read · pseudocode_at

• Lists the outside functions the binary uses

  Returns each imported symbol with its name and address. It shows at a glance whether a binary uses networking, files or crypto libraries.

  Try: “List the imports and tell me which ones touch the network.”

  Read · imports

• Lists the functions the binary offers to others

  Returns every exported function or symbol with its address and name.

  Try: “List the exports of this library.”

  Read · exports

• Lists where execution can start

  Returns the binary's entry points, such as main or DllMain.

  Try: “What are the entry points of this binary?”

  Read · entrypoints

• Lists the memory sections and their permissions

  Returns each segment with its address range, size, name and read, write and execute flags. Sections that are both writable and executable stand out here.

  Try: “List the segments and flag any that are writable and executable.”

  Read · segments

• Summarizes the open file

  Reports file type, loader, processor, bit width, function count, size, hashes and the main addresses of the database that is open.

  Try: “Give me a summary of the open binary, including its hashes.”

  Read · idb_meta

• Describes what sits at an address

  Returns the segment, containing function and nearest symbol for one address.

  Try: “What is at 0x100020010?”

  Read · addr_info

• Lists global variables and data items

  Returns globals with their addresses, names and types.

  Try: “List the global variables with their types.”

  Read · list_globals

• Exports functions as JSON

  Writes out function details as JSON for all functions or only the addresses you list, so the output can go into other tools.

  Try: “Export the functions at these three addresses as JSON.”

  Read · export_funcs

• Reads raw bytes at an address

  Returns the bytes at an address, or at a symbol plus an offset, as a hex string.

  Try: “Read 32 bytes at the start of the function named init_table.”

  Read · get_bytes

• Reads the string stored at an address

  Reads the text at one or more addresses, including the string types IDA recognizes beyond plain C strings.

  Try: “Read the string at 0x100050000.”

  Read · get_string

• Reads whole numbers from memory

  Reads unsigned integers of 1, 2, 4 or 8 bytes at each address you give, using the file's byte order.

  Try: “Read a 4-byte value at 0x100060000.”

  Read · read_int

• Reads a global variable's value

  Returns the value and raw bytes of a global, picked by name or address.

  Try: “What is the value of the global named g_config_size?”

  Read · get_global_value

• Searches for a byte pattern

  Looks for a sequence of bytes, with wildcards allowed, and returns the matching addresses up to a limit.

  Try: “Find every place with the bytes 48 8b ?? ?? 48 85 c0.”

  Read · find_bytes

• Searches text or constant values in code

  A general search for text strings or immediate values inside instructions. For raw byte patterns, find_bytes is the better fit.

  Try: “Search for the constant 0xdeadbeef in the code.”

  Read · search

• Finds instruction patterns by mnemonic

  Searches for instructions by their mnemonic, and for a list of patterns it matches runs of instructions one after another.

  Try: “Find places where a "syscall" instruction follows a "mov" instruction.”

  Read · find_insns

• Finds instructions by their operands

  Returns instructions whose operand text contains any of the pieces of text you give, with the address, mnemonic and full line.

  Try: “Find instructions that use the operand "gs:".”

  Read · find_insn_operands

• Lists the types defined in the database

  Returns typedefs, enums, structs and other local types a page at a time, with an optional filter.

  Try: “List the local types that mention "socket".”

  Read · local_types

• Lists the structs in the database

  Returns structs with optional name filtering and paging.

  Try: “List all structs whose name starts with "Http".”

  Read · structs

• Shows one struct's layout

  Returns a struct's members with their offsets and sizes, found by name or number.

  Try: “Show the layout of struct HttpRequest.”

  Read · struct_info

• Finds structs by name

  Searches structs by name with optional paging and returns the same list format as structs.

  Try: “Find structs with "header" in the name.”

  Read · search_structs

• Reads memory as a struct

  Reads the raw bytes for each member of a struct at the address you give.

  Try: “Read the Session struct at 0x100070000.”

  Read · read_struct

• Shows a function's stack layout

  Returns the stack frame of the function at an address, including argument and local ranges and the type of each member.

  Try: “Show the stack frame of the function at 0x100003f50.”

  Read · stack_frame

• Guesses the type at an address

  Asks IDA's own heuristics to guess a type for an address or symbol. It returns a suggestion and changes nothing.

  Try: “What type does IDA guess for the data at 0x100070000?”

  Read · infer_types

• Lists a function's local variables

  Returns decompiler local variables and arguments with names, types and locations. It also returns the edit locators that rename_lvar and set_lvar_type need.

  Try: “List the local variables of the function named parse_header.”

  Read · list_lvars

• Lists where comments can go in decompiled code

  Returns each commentable line of a function's pseudocode with its locator, address and any existing comment.

  Try: “Show the comment slots in the decompiled parse_header.”

  Read · list_pseudocode_comments

• Looks up a function in Hex-Rays' Lumina service

  Asks the configured Lumina server what it knows about a function and reports the metadata without changing the database. It fails with an error until the server is started with Lumina allowed.

  Try: “Check whether Lumina knows the function at 0x100003f50.”

  Network · lumina_lookup

• Pulls Lumina names and types onto a function

  Fetches metadata for one function from the configured Lumina server and applies it. Turning on force can replace names, types or comments you already set. It fails with an error until the server is started with Lumina allowed.

  Try: “Apply Lumina metadata to the function at 0x100003f50.”

  Write · lumina_apply

• Lists bytes that have been patched

  Shows the patched byte ranges recorded in the database, optionally within a start and end address. It does not change anything.

  Try: “Show every patch made so far in this database.”

  Read · list_patches

• Renames a function or symbol

  Changes the name of a symbol at an address, or finds it by its current name. A name that does not match exactly changes nothing and returns similar names instead.

  Try: “Rename the function at 0x100003f50 to parse_config_header.”

  Write · rename

• Renames a local variable in decompiled code

  Saves a new name for one local variable in a function, chosen by the locator from list_lvars. A stale or ambiguous choice changes nothing.

  Try: “Rename the local v3 in parse_header to buffer_len.”

  Write · rename_lvar

• Sets the type of a local variable

  Parses a C type and applies it to one local variable in a function, chosen by locator. Invalid or incompatible types are rejected.

  Try: “Set the type of the local buffer_len in parse_header to unsigned int.”

  Write · set_lvar_type

• Adds a comment in the assembly listing

  Sets or clears a comment at an address, normal or repeatable. An empty string clears it. These comments do not show in decompiled code.

  Try: “Add a comment at 0x100004120 saying this is the license check.”

  Write · set_comments

• Adds a comment in the decompiled code

  Sets, replaces or removes one end-of-line comment in a function's pseudocode, chosen by locator. Empty text removes the comment, and save_idb writes it to disk.

  Try: “Comment the check at line 14 of parse_header: validates magic number.”

  Delete · set_pseudocode_comment

• Adds a type from a C declaration

  Parses a C declaration and stores it in the local type library, optionally replacing an existing type.

  Try: “Declare struct Packet { unsigned int len; char data[64]; }.”

  Write · declare_type

• Applies a type to an address or variable

  Gives an address or symbol a named type or a C declaration. For stack variables, you pass the offset or name with the declaration.

  Try: “Apply the type struct Packet to the data at 0x100070000.”

  Write · apply_types

• Defines a variable in a function's stack frame

  Creates a stack variable from a C declaration at a given offset in a function's frame. Negative offsets are locals.

  Try: “Declare an int named retries at stack offset -0x14 in parse_header.”

  Write · declare_stack

• Removes a stack variable

  Deletes a stack variable from a function frame, found by name or offset.

  Try: “Delete the stack variable at offset -0x14 in parse_header.”

  Delete · delete_stack

• Changes bytes in the database

  Writes new bytes at an address, or at a symbol plus offset. The change goes into the IDA database, and save_idb stores it. It does not rewrite the original program file.

  Try: “Patch the 4 bytes at 0x100004120 with a NOP (1f 20 03 d5).”

  Write · patch

• Patches an instruction from assembly text

  Assembles one line of assembly and writes the bytes at an address. It needs a processor module with assembler support, so it can fail on some targets.

  Try: “Replace the instruction at 0x100004120 with nop.”

  Write · patch_asm

• Opens a binary or IDA database for analysis

  Opens an .i64 or .idb database, or a raw Mach-O, ELF or PE file. A raw file gets a new .i64 saved next to it unless you choose another folder, and an existing one is reused only if its recorded file hash matches. With rebuild turned on it can overwrite a database it created for that file.

  Try: “Open ~/samples/suspicious.bin and save the database in ~/ida-work/.”

  Write · open_idb

• Opens one module from an Apple dyld shared cache

  Opens a dyld_shared_cache file and loads a single library from it for analysis. It can load extra frameworks so cross-references resolve.

  Try: “Open libobjc.A.dylib from this arm64e dyld shared cache.”

  Write · open_dsc

• Adds another library to an open shared cache

  Loads one more library into a database opened with open_dsc, without running full analysis. Check analysis status afterwards.

  Try: “Add libSystem.B.dylib to the open shared cache database.”

  Write · dsc_add_dylib

• Adds a memory region from a shared cache

  Loads a data, GOT or stub region at one address into a database opened with open_dsc.

  Try: “Load the region at 0x180116000 from the shared cache.”

  Write · dsc_add_region

• Loads debug symbols into the database

  Loads outside debug info, such as DWARF from a dSYM, into the open database. If you give no path it looks for a dSYM next to the file.

  Try: “Load the dSYM that sits next to this binary.”

  Write · load_debug_info

• Runs IDA's automatic analysis

  Starts auto-analysis so functions and references are complete. For large files it can run in the background and give a task id to poll.

  Try: “Run auto-analysis on this binary in the background.”

  Write · analyze_funcs

• Checks whether analysis has finished

  Reports whether IDA's auto-analysis is done, so the assistant knows if cross-references and decompiling can be trusted yet.

  Try: “Is the analysis finished?”

  Read · analysis_status

• Saves your work to the database file

  Writes the open database to disk and keeps it open. Use it to checkpoint renames, comments, types and patches. close_idb also saves.

  Try: “Save the database now.”

  Write · save_idb

• Closes the open database

  Closes the current database and releases it, saving first. Do this before opening a different file.

  Try: “Close the database.”

  Write · close_idb

• Runs Python code inside IDA

  Runs a Python script, inline or from a file, in the open database with IDAPython. It can use every IDA module, keeps variables between calls and returns printed output and a final result. A script can do anything Python can do on your computer, not just read the binary.

  Try: “Run a script that lists every function with more than 20 basic blocks.”

  Runs code · run_script

• Used by the assistant behind the scenes

  Searches the tool list by what you want to do

  Searches the server's tools by intent, such as "find callers", and returns names with short descriptions.

  Try: “Which tool should I use to find callers of a function?”

  Read · tool_catalog

• Shows the full help for one tool

  Returns the complete documentation, parameters and an example for a named tool.

  Try: “Show the help for the patch tool.”

  Read · tool_help

• Shows what the server did last

  Returns the operation in progress and a short trail of recent steps from opening, scripting and analysis. Useful after a timeout or failure.

  Try: “What was the server doing when that call timed out?”

  Read · recent_operations

• Checks a background job

  Reports whether a background task, such as loading a shared-cache module, is running, finished or failed.

  Try: “Is the shared cache load finished?”

  Read · task_status

Watch out for

• The script tool runs any Python on your machine

  run_script executes Python inside IDA with full access to its modules, and Python can also read files and start programs. Use --read-only unless you need scripting, and keep sensitive files out of reach. github.com

• It can patch, rename and overwrite database files

  Patch, rename, comment and type tools edit the IDA database, and save_idb or close_idb write it to disk. Opening a file with rebuild turned on can overwrite a database the server made earlier. github.com

• The opt-in debugger can start and stop processes

  With --enable-debugger on Apple Silicon Mac, debug_launch starts a program and debug_attach attaches to a running process. Leave it off for static analysis. github.com

• Opening a hostile file runs it through IDA's loaders

  Our advice: open untrusted samples only in a virtual machine or other isolated system. Loading malware with a disassembler is normal, but a bug in a loader is possible. github.com

• Read-only mode is not a file sandbox

  The README says --read-only filters tools only. Opening a binary still creates its .i64 database file on disk. github.com

• Network mode has no sign-in

  The docs describe Origin and Host header checks for the optional HTTP mode, not a login. It listens on 127.0.0.1 by default; keep it there, because binding it to 0.0.0.0 exposes every tool, including the script tool, to your network. github.com

Security advisories