Skip to main content
Glama
Frida Game Hacking MCP

Frida Game Hacking MCP

by 0xhackerfren

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.

MCP Python Frida License

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_unchanged

  • Pattern 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/onLeave JavaScript callbacks

  • Replace Functions: Make functions return custom values

  • Module Hooking: Hook by module!function name

  • Symbol 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 pywin32

Quick Start

Run the MCP Server

# Run directly
python -m frida_game_hacking_mcp

# Or use the entry point
frida-game-hacking-mcp

Configure 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_mcp

  • Transport: 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-endian

Array 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 regions

Function 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

list_processes

Enumerate running processes

attach

Attach to process by name or PID

detach

Detach from current process

spawn

Start process suspended

resume

Resume spawned process

get_session_info

Get current session status

Memory Operations (10)

Tool

Description

read_memory

Read bytes at address

write_memory

Write bytes/values to address

scan_value

Initial scan for exact value

scan_next

Narrow scan with new value

scan_changed

Find changed values

scan_unchanged

Find unchanged values

scan_pattern

AoB pattern scan with wildcards

get_scan_results

Get current scan results

clear_scan

Reset scan state

list_memory_regions

List memory regions

Module Information (5)

Tool

Description

list_modules

List loaded modules/DLLs

get_module_info

Get module details

get_module_exports

List module exports

get_module_imports

List module imports

resolve_symbol

Resolve symbol to address

Function Hooking (6)

Tool

Description

hook_function

Hook with callbacks

unhook_function

Remove hook

replace_function

Replace function return

hook_native_function

Hook with calling convention

list_hooks

List active hooks

intercept_module_function

Hook by module!function

Debugging (4)

Tool

Description

set_breakpoint

Set software breakpoint

remove_breakpoint

Remove breakpoint

list_breakpoints

List breakpoints

read_registers

Read CPU registers

Script Management (3)

Tool

Description

load_script

Load custom Frida JS

unload_script

Unload script

call_rpc

Call script RPC export

Window Interaction (5) - Windows Only

Tool

Description

list_windows

Enumerate visible windows

screenshot_window

Capture window to PNG/base64

screenshot_screen

Capture screen or region

send_key_to_window

Send keystrokes to window

focus_window

Bring window to foreground

Standard MCP (3)

Tool

Description

list_capabilities

List all tools

get_documentation

Get help and examples

check_installation

Verify Frida installed

Value Types

Type

Size

Description

int8

1 byte

Signed byte

uint8

1 byte

Unsigned byte

int16

2 bytes

Signed short

uint16

2 bytes

Unsigned short

int32

4 bytes

Signed int (most common)

uint32

4 bytes

Unsigned int

int64

8 bytes

Signed long

uint64

8 bytes

Unsigned long

float

4 bytes

Single precision

double

8 bytes

Double precision

string

Variable

Null-terminated string

Scan Regions

Region

Description

rw-

Read-write data (heap, stack, globals) - default for value scans

r-x

Executable code - default for pattern scans

rwx

Read-write-execute (rare, often exploitable)

r--

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:

  1. Fork the repository

  2. Create a feature branch

  3. Submit a pull request

License

MIT License - see LICENSE

Credits


Built for AI-assisted game hacking and security research.

Available Tools

42 tools
attachB
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

    A3.5/5.0

    Scored across 42 tools

    Disambiguation4/5

    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.

    Naming Consistency5/5

    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.

    Tool Count3/5

    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.

    Completeness5/5

    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

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      Not graded
      maintenance
      Enables 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.
      14
      2
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables 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.
      3
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      A 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.
      55
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Enables AI agents to programmatically control Cheat Engine for memory scanning, editing, cheat table management, and reverse engineering tasks.
      42
      MIT