Frida Game Hacking MCP
Enables memory scanning, value modification, function hooking, and code injection in Android applications via frida-server.
Enables memory scanning, value modification, function hooking, and code injection in iOS applications via frida-server on jailbroken devices.
Provides Cheat Engine-like capabilities for memory editing, pattern scanning, function hooking, and runtime analysis of Linux processes.
Provides Cheat Engine-like capabilities for memory editing, pattern scanning, function hooking, and runtime analysis of macOS processes.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Frida Game Hacking MCP scan for my health value, it's currently 100"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Frida Game Hacking MCP
A Model Context Protocol (MCP) server that provides Cheat Engine-like capabilities for game hacking through Frida. Enables AI assistants and automation tools to perform memory scanning, value modification, pattern matching, function hooking, and code injection.
Features
Memory Operations (Cheat Engine Style)
Value Scanning: Find values in memory by type (int8-64, float, double, string)
Scan Refinement: Narrow results with
scan_next,scan_changed,scan_unchangedPattern Scanning: Array of Bytes (AoB) with wildcard support (
??)Memory Read/Write: Read and modify memory with type awareness
Function Hooking & Code Injection
Intercept Functions: Hook with
onEnter/onLeaveJavaScript callbacksReplace Functions: Make functions return custom values
Module Hooking: Hook by
module!functionnameSymbol Resolution: Resolve exports to addresses
Process Management
Process Enumeration: List and filter running processes
Attach/Detach: Connect to running processes
Spawn & Resume: Start processes suspended for early hooking
Debugging
Breakpoints: Software breakpoints via hooks
Register Access: Read CPU registers at breakpoints
Module Analysis: List modules, exports, imports
Window Interaction (Windows)
Screenshot Capture: Take screenshots of game windows
Keyboard Input: Send keystrokes to game windows
Window Management: List, focus, and interact with windows
Related MCP server: Frida MCP Server
Installation
# Install from PyPI (coming soon)
pip install frida-game-hacking-mcp
# Or install from source
git clone https://github.com/0xhackerfren/frida-game-hacking-mcp.git
cd frida-game-hacking-mcp
pip install -e .Requirements
Python 3.10+
Frida 16.0+
pywin32, pillow (Windows, for screenshot features)
pip install frida frida-tools mcp pillow
# On Windows, also install:
pip install pywin32Quick Start
Run the MCP Server
# Run directly
python -m frida_game_hacking_mcp
# Or use the entry point
frida-game-hacking-mcpConfigure with Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"frida-game-hacking": {
"command": "python",
"args": ["-m", "frida_game_hacking_mcp"]
}
}
}Configure with Other MCP Clients
The server uses stdio transport by default. Connect using:
Command:
python -m frida_game_hacking_mcpTransport: stdio
Usage Examples
Cheat Engine Workflow: Find and Modify Health
1. List processes and find your game
> list_processes("game")
2. Attach to the game
> attach("game.exe")
3. Initial scan for current health value (e.g., 100)
> scan_value(100, "int32")
Found: 58,869 addresses
4. Take damage in game (health now 95)
> scan_next(95)
Narrowed to: 1,419 addresses
5. Repeat until you find the address
> scan_next(90)
Narrowed to: 3 addresses
6. Get results and modify
> get_scan_results()
> write_memory("0x12345678", "E7030000") # 999 in little-endianArray of Bytes Pattern Scanning
# Find code pattern (works across game updates)
> attach("game.exe")
> scan_pattern("89 47 44 ?? ?? 5B 7A", "r-x")
Found: 2 matches
# ?? = wildcard bytes
# "r-x" = executable memory regionsFunction Hooking
# Hook a function and log calls
> hook_function("0x401234",
on_enter="console.log('Args:', args[0], args[1]);",
on_leave="console.log('Return:', retval);")
# Make a function always return success
> replace_function("0x401234", 1)
# Hook by module and function name
> intercept_module_function("game.dll", "CheckLicense",
on_leave="retval.replace(1);")Early Hooking (Spawn Suspended)
# Start process suspended
> spawn("C:/Games/game.exe")
# Set up hooks before code runs
> hook_function("0x401234", on_enter="...")
# Resume execution
> resume()Available Tools (42 Total)
Process Management (6)
Tool | Description |
| Enumerate running processes |
| Attach to process by name or PID |
| Detach from current process |
| Start process suspended |
| Resume spawned process |
| Get current session status |
Memory Operations (10)
Tool | Description |
| Read bytes at address |
| Write bytes/values to address |
| Initial scan for exact value |
| Narrow scan with new value |
| Find changed values |
| Find unchanged values |
| AoB pattern scan with wildcards |
| Get current scan results |
| Reset scan state |
| List memory regions |
Module Information (5)
Tool | Description |
| List loaded modules/DLLs |
| Get module details |
| List module exports |
| List module imports |
| Resolve symbol to address |
Function Hooking (6)
Tool | Description |
| Hook with callbacks |
| Remove hook |
| Replace function return |
| Hook with calling convention |
| List active hooks |
| Hook by module!function |
Debugging (4)
Tool | Description |
| Set software breakpoint |
| Remove breakpoint |
| List breakpoints |
| Read CPU registers |
Script Management (3)
Tool | Description |
| Load custom Frida JS |
| Unload script |
| Call script RPC export |
Window Interaction (5) - Windows Only
Tool | Description |
| Enumerate visible windows |
| Capture window to PNG/base64 |
| Capture screen or region |
| Send keystrokes to window |
| Bring window to foreground |
Standard MCP (3)
Tool | Description |
| List all tools |
| Get help and examples |
| Verify Frida installed |
Value Types
Type | Size | Description |
| 1 byte | Signed byte |
| 1 byte | Unsigned byte |
| 2 bytes | Signed short |
| 2 bytes | Unsigned short |
| 4 bytes | Signed int (most common) |
| 4 bytes | Unsigned int |
| 8 bytes | Signed long |
| 8 bytes | Unsigned long |
| 4 bytes | Single precision |
| 8 bytes | Double precision |
| Variable | Null-terminated string |
Scan Regions
Region | Description |
| Read-write data (heap, stack, globals) - default for value scans |
| Executable code - default for pattern scans |
| Read-write-execute (rare, often exploitable) |
| Read-only data |
Platform Support
Windows: Native support
Linux: Native support
macOS: Native support
Android: Via frida-server
iOS: Via frida-server (jailbroken)
Use Cases
Game Hacking: Memory editing, value modification, trainer development
Security Research: Vulnerability analysis, exploit development
Reverse Engineering: Runtime analysis, API hooking
Software Testing: Fault injection, behavior modification
Malware Analysis: Dynamic analysis in sandboxed environments
Security Notice
This tool is intended for:
Educational purposes
Security research on software you own or have permission to test
Game modding in single-player/offline contexts
Do not use for:
Cheating in online multiplayer games
Circumventing software protections illegally
Any malicious purposes
Contributing
Contributions welcome! Please:
Fork the repository
Create a feature branch
Submit a pull request
License
MIT License - see LICENSE
Credits
Built on Frida by Ole Andre Vadla Ravnas
MCP protocol by Anthropic
Inspired by Cheat Engine by Dark Byte
Links
Built for AI-assisted game hacking and security research.
Available Tools
42 toolsattachB
Attach to a running process.
Args:
target: Process name (string) or PID (integer)
Returns:
Session information.
Inputs: target (required). Returns: result
call_rpcB
Call an RPC export from a loaded script.
Args:
name: Name of the loaded script
method: RPC method name to call
args: Arguments to pass
Returns:
RPC result.
Inputs: name (required), method (required), args. Returns: result
check_installationA
Check if Frida is installed and working.
Returns:
Installation status and version information.
Inputs: no named parameters. Returns: result
clear_scanA
Clear current scan results and reset scan state.
Returns:
Confirmation message.
Inputs: no named parameters. Returns: result
detachC
Detach from the current process.
Returns:
Detach status.
Inputs: no named parameters. Returns: result
focus_windowB
Bring a window to the foreground.
Args:
target: Window title (string) or HWND handle (integer)
Returns:
Success status.
Inputs: target (required). Returns: result
get_documentationC
Get documentation and usage examples.
Args:
topic: Documentation topic (general, memory, hooking, scanning, examples)
Returns:
Documentation for the requested topic.
Inputs: topic. Returns: result
get_module_exportsC
List exports from a module.
Args:
module_name: Name of the module
filter_name: Optional filter for export names
Returns:
List of exports with name and address.
Inputs: module_name (required), filter_name. Returns: result
get_module_importsB
List imports for a module.
Args:
module_name: Name of the module
filter_name: Optional filter for import names
Returns:
List of imports with name, module, and address.
Inputs: module_name (required), filter_name. Returns: result
get_module_infoB
Get detailed information about a specific module.
Args:
module_name: Name of the module (e.g., "game.dll")
Returns:
Module details including base, size, exports count.
Inputs: module_name (required). Returns: result
get_scan_resultsB
Get current scan results with values.
Args:
limit: Maximum results to return (default: 20)
Returns:
List of addresses and their current values.
Inputs: limit. Returns: result
get_session_infoA
Get current session information.
Returns:
Session state including attached process, hooks, scan state.
Inputs: no named parameters. Returns: result
hook_functionB
Hook a function at the specified address.
Args:
address: Address to hook (hex string)
on_enter: JavaScript code for onEnter (has access to 'args' array)
on_leave: JavaScript code for onLeave (has access to 'retval')
description: Optional description
Returns:
Hook status.
Inputs: address (required), on_enter, on_leave, description. Returns: result
hook_native_functionB
Hook a native function with explicit calling convention.
Args:
address: Address of function
calling_convention: "default", "stdcall", "fastcall", "thiscall"
arg_types: List of argument types
return_type: Return type
on_enter: JavaScript for onEnter
on_leave: JavaScript for onLeave
Returns:
Hook status.
Inputs: address (required), calling_convention, arg_types, return_type, +2 more. Returns: result
intercept_module_functionC
Hook a function by module and function name.
Args:
module_name: Name of the module (e.g., "game.dll")
function_name: Name of the exported function
on_enter: JavaScript for onEnter
on_leave: JavaScript for onLeave
Returns:
Hook status with resolved address.
Inputs: module_name (required), function_name (required), on_enter, on_leave. Returns: result
list_breakpointsB
List all active breakpoints.
Inputs: no named parameters. Returns: result
list_capabilitiesA
List all tools provided by this MCP server.
Returns:
Dictionary with MCP info and available tools organized by category.
Inputs: no named parameters. Returns: result
list_hooksB
List all active hooks.
Returns:
List of active hooks with addresses and descriptions.
Inputs: no named parameters. Returns: result
list_memory_regionsB
List memory regions in the process.
Args:
protection: Filter by protection (e.g., "r-x", "rw-", "rwx")
Returns:
List of memory regions with base, size, and protection.
Inputs: protection. Returns: result
list_modulesA
List all loaded modules (DLLs/shared libraries).
Returns:
List of modules with base address, size, and path.
Inputs: no named parameters. Returns: result
list_processesB
List all running processes.
Args:
filter_name: Optional filter to match process names (case-insensitive)
Returns:
List of processes with PID and name.
Inputs: filter_name. Returns: result
list_windowsA
List all visible windows.
Args:
filter_name: Optional filter to match window titles (case-insensitive)
Returns:
List of windows with handle, title, and associated PID.
Inputs: filter_name. Returns: result
load_scriptB
Load a custom Frida JavaScript script.
Args:
script_code: JavaScript code to load
name: Name to identify the script
Returns:
Load status.
Inputs: script_code (required), name. Returns: result
read_memoryB
Read memory at specified address.
Args:
address: Memory address (hex string like "0x401234")
size: Number of bytes to read
format: Output format ("hex", "bytes", "int32", "float", "string")
Returns:
Memory contents in requested format.
Inputs: address (required), size, format. Returns: result
read_registersB
Read CPU register values.
Note: Full register context available in hook callbacks via 'this.context'.
Returns:
Basic thread and architecture info.
Inputs: no named parameters. Returns: result
remove_breakpointB
Remove a breakpoint.
Args:
address: Address of breakpoint to remove
Returns:
Removal status.
Inputs: address (required). Returns: result
replace_functionC
Replace a function to always return a specific value.
Args:
address: Address of function to replace
return_value: Value to return
Returns:
Replacement status.
Inputs: address (required), return_value. Returns: result
resolve_symbolB
Resolve a symbol to its address.
Args:
module_name: Name of the module containing the symbol
symbol_name: Name of the symbol/function
Returns:
Address of the symbol.
Inputs: module_name (required), symbol_name (required). Returns: result
resumeB
Resume a spawned process.
Returns:
Resume status.
Inputs: no named parameters. Returns: result
scan_changedB
Find addresses where value has changed since last scan.
Returns:
Number of changed addresses.
Inputs: no named parameters. Returns: result
scan_nextC
Narrow scan results with new value.
Args:
value: New value to search for
Returns:
Number of remaining addresses.
Inputs: value (required). Returns: result
scan_patternB
Scan for Array of Bytes (AoB) pattern.
Args:
pattern: Byte pattern like "89 47 44 ?? ?? 5B" (?? = wildcard)
scan_regions: Memory protection to scan (default: "r-x" for code)
Returns:
List of matching addresses.
Inputs: pattern (required), scan_regions. Returns: result
scan_unchangedB
Find addresses where value has NOT changed since last scan.
Returns:
Number of unchanged addresses.
Inputs: no named parameters. Returns: result
scan_valueA
Scan memory for exact value (initial scan).
Args:
value: Value to search for
value_type: Type ("int8", "int16", "int32", "int64", "float", "double", "string")
scan_regions: Memory protection to scan (default: "rw-" for data)
Returns:
Number of addresses found.
Inputs: value (required), value_type, scan_regions. Returns: result
screenshot_screenA
Take a screenshot of the entire screen or a region.
Args:
save_path: Optional path to save the screenshot (PNG). If empty, returns base64.
region: Optional [x, y, width, height] to capture specific region.
Returns:
Screenshot info with base64 data or saved file path.
Inputs: save_path, region. Returns: result
screenshot_windowA
Take a screenshot of a specific window.
Args:
target: Window title (string) or HWND handle (integer)
save_path: Optional path to save the screenshot (PNG). If empty, returns base64.
Returns:
Screenshot info with base64 data or saved file path.
Inputs: target (required), save_path. Returns: result
send_key_to_windowA
Send a keystroke to a specific window.
Args:
target: Window title (string) or HWND handle (integer)
key: Key to send (e.g., "a", "enter", "space", "up", "down", "left", "right")
use_sendinput: If True, use SendInput (requires window focus). If False, use PostMessage.
Returns:
Success status.
Inputs: target (required), key (required), use_sendinput. Returns: result
set_breakpointC
Set a software breakpoint at address.
Args:
address: Address for breakpoint
callback: JavaScript code to execute when hit
Returns:
Breakpoint status.
Inputs: address (required), callback. Returns: result
spawnA
Spawn a process suspended for early hooking.
Args:
path: Path to executable
args: Optional command line arguments
Returns:
Spawn information. Call resume() to start execution.
Inputs: path (required), args. Returns: result
unhook_functionC
Remove a hook from an address.
Args:
address: Address to unhook
Returns:
Unhook status.
Inputs: address (required). Returns: result
unload_scriptC
Unload a custom script.
Args:
name: Name of the script to unload
Returns:
Unload status.
Inputs: name (required). Returns: result
write_memoryB
Write data to memory address.
Args:
address: Memory address (hex string like "0x401234")
data: Data to write (hex string, or value if value_type specified)
value_type: Type of data ("bytes", "int32", "float", "string", etc.)
Returns:
Write status.
Inputs: address (required), data (required), value_type. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 42 tools
Most tools have distinct purposes, but some overlap exists, such as hook_function, hook_native_function, and intercept_module_function, which all handle function hooking with slight variations. Similarly, scan_value, scan_pattern, scan_next, scan_changed, and scan_unchanged are all related to memory scanning, which could cause confusion. However, descriptions help differentiate them, and overall, the tool set is well-organized with clear categories.
Tool names follow a consistent snake_case pattern throughout, with clear verb_noun structures (e.g., attach, detach, list_processes, read_memory). There are no deviations in naming conventions, making the set predictable and easy to navigate. This consistency aids in understanding and using the tools effectively.
With 42 tools, the count is high, bordering on heavy for a game hacking server. While the domain is broad, covering process management, memory operations, hooking, scanning, and UI interactions, it may overwhelm users or agents. A more streamlined set could improve usability without sacrificing functionality, as some tools are highly specialized.
The tool set provides comprehensive coverage for game hacking, including process attachment/detachment, memory reading/writing, function hooking, scanning, breakpoints, script management, and UI controls. There are no obvious gaps; it supports full CRUD-like operations for hooks, scripts, and scans, and includes utilities like documentation and capability listing, ensuring agents can handle complex workflows without dead ends.
Maintenance
Related MCP Connectors
Evidence-oriented REA + Ghidra static-analysis workflows, read-only PE32 and Delphi VMT tools.
Offline methodology engine for authorized penetration testing, CTF, and security research.
Reasoning, code, anti-deception, memory harness MCP tools. Stdio or HTTPS api.ejentum.com/mcp
Security scanner for MCP servers. Detect vulnerabilities, prompt injection, and tool poisoning.
Related MCP Servers
- AlicenseBqualityNot gradedmaintenanceEnables AI systems to interact with mobile and desktop applications through Frida's dynamic instrumentation capabilities. Provides process management, device control, JavaScript REPL execution, and script injection for runtime analysis and reverse engineering.142MIT
- AlicenseNot gradedqualityDmaintenanceEnables dynamic instrumentation of running processes through Frida, allowing users to hook functions, inspect memory, modify process behavior, and execute JavaScript code for debugging and reverse engineering.3MIT
- AlicenseBqualityCmaintenanceA comprehensive MCP server that exposes Frida's dynamic instrumentation toolkit to AI agents for process management, script injection, and memory operations. It provides over 50 tools to interact with local and mobile devices, enabling advanced capabilities like function hooking and memory analysis.55MIT
- AlicenseBqualityDmaintenanceEnables AI agents to programmatically control Cheat Engine for memory scanning, editing, cheat table management, and reverse engineering tasks.42MIT