Frida C2 MCP

FridaC2MCP is a proof - of - concept project that exposes the capabilities of the Frida dynamic instrumentation tool as a remote MCP server through HTTP streaming, aiming to achieve remote and automated mobile application security testing. The project is designed to run on a rooted Android device, allowing clients to analyze and manipulate running applications over the network.

Security Developer tools #Mobile security #Dynamic instrumentation #Remote control #Automated testing .Python

rating : 2.5 points

downloads : 6.2K

update time : 2026-03-13

Open Site

What is FridaC2MCP?

FridaC2MCP is an innovative proof - of - concept tool that packages the capabilities of the powerful dynamic code instrumentation tool Frida into a server that can be remotely accessed over the network. Simply put, it allows you to control an Android phone over the network from your computer, and view and modify the internal operations of the applications running on the phone in real - time.

How to use FridaC2MCP?

The usage is divided into two steps: 1. Start the FridaC2MCP server on a rooted Android device. 2. Communicate with the server by sending HTTP requests from your computer or an automated tool (such as an AI agent) to perform operations such as listing applications, starting applications, and injecting code.

Applicable scenarios

It is mainly targeted at mobile application security researchers and automated testing scenarios. For example, security engineers can remotely test the defense mechanisms of an application; or an AI agent can automatically perform a series of security testing steps, such as bypassing the root detection of an application and intercepting encrypted communications.

Main features

Application and process management

Remotely view all applications installed on the device, currently running processes, and obtain information about the foreground application.

Remote application control

You can remotely start or terminate an application by specifying the application package name or process ID.

Dynamic code instrumentation

Core function. You can 'attach' to any running application process, create an interactive session, and observe and modify its code logic in real - time.

Remote script execution

Execute custom JavaScript code (Frida scripts) in the attached session. The server will automatically handle the compatibility packaging of the scripts, supporting one - time execution and persistent hooks.

Streaming HTTP transmission

Using HTTP instead of simple command - line interaction, it supports multiple clients to connect simultaneously, laying the foundation for future complex multi - device collaborative testing (Agent - to - Agent).

Advantages

Remote operation: There is no need to connect with a USB cable. Testers can operate the device anywhere within the reach of the network.

Zero - dependency on the client: There is no need to install any Frida - related tools on the control computer. All functions are completed on the target device.

Easy to automate: The standard HTTP interface is very suitable for being called by scripts, automation frameworks, or AI agents to implement an automated security testing process.

Supports modern Frida: It has a built - in script packaging function and is compatible with the requirements of Frida 17+ for JavaScript code.

Limitations and precautions

Proof - of - concept stage: The current version is an early prototype, with imperfect functions and a lack of perfect session management and error handling.

No security guarantee: All network communications are in plain text, and there is no authentication. It can only be used in a completely trusted and isolated network environment; otherwise, there are serious security risks.

High device requirements: The server must run on a rooted Android device, which limits the scope of use.

Complex configuration: You need to manually compile and deploy Frida and related dependencies on the Android device, which has a certain technical threshold for users.

How to use

Environment preparation

Prepare a rooted Android device (such as installing Termux), and manually compile and deploy Frida, the Python environment, and the dependencies of this project on it.

Start the server

Run the FridaC2MCP server program on the Android device, and it will start listening on the specified network port.

Client connection

From your computer or an automated tool, use any HTTP client (such as curl, Postman, or a custom script) to send requests to the server's address and port.

Execute operations

According to the API documentation, send different HTTP requests to perform specific operations, such as attaching to a process and executing scripts.

Usage cases

Case: Remotely bypass the root detection of an application

Security testers need to test the robustness of the root detection mechanism of a mobile banking application (such as owasp.sat.agoat).

Case: Automatically collect application information

An AI - driven security testing agent needs to automatically analyze all social applications on the device.

Frequently Asked Questions

Do I have to have a rooted Android phone to use it?

Is this tool secure? Can I use it on the public network?

What's the difference from the original Frida? Why not use a USB connection?

Does it support iOS?

Related resources

GitHub project homepage

Get the latest source code, release versions, and detailed technical documentation.

Frida official documentation

Learn the core concepts and JavaScript API of the Frida tool itself, which is the basis for writing effective hook scripts.

TLDR InfoSec special report

View the introduction and review of the FridaC2MCP project by TLDR InfoSec.

Inspiration source: FridaMCP

Understand the inspiration source of this project, a Frida MCP server prototype based on stdio.

🚀 FridaC2MCP

A proof-of-concept, MCP server with streamable HTTP transport that exposes Frida's powerful dynamic instrumentation capabilities as a simple, remote server.

This project is designed to run directly on a rooted Android device (e.g., within Termux) and allow a remote client to analyze and manipulate running applications over the network. It acts as a bridge, turning Frida functions into tools that can be called via HTTP requests, with the goal of enabling automated, agent-based mobile security testing.

Link

✨ Features

Process & Application Management: List installed applications, enumerate running processes, and get information about the foreground application.
Application Control: Start and terminate applications by their identifier or PID.
Dynamic Instrumentation: Create interactive sessions by attaching to running processes.
Remote Script Execution: Execute custom Frida (JavaScript) scripts within an attached session. Scripts are bundled on-the-fly using esbuild to ensure compatibility with modern Frida versions. This supports both temporary scripts and persistent hooks (keep_alive=True).

🚀 Quick Start

The primary goal of this project is to facilitate remote and automated mobile application security testing. By exposing Frida as an MCP server, a pentester or an automated agent (such as an LLM) can inspect and modify an application's behavior without needing a direct USB connection or local shell access after initial setup. The client does not need any Frida tooling installed as it is all contained on the target device.

A typical use case involves:

Starting a target application on the device remotely.
Attaching a Frida session to the application.
Injecting a JavaScript hook to bypass security controls, such as the root detection check in owasp.sat.agoat.
Observing the change in the application's behavior.

🔧 Technical Details

The system operates on a client - server model with specific design choices to enable its unique, on - device execution environment.

Server (cli.py): A Python script using FastMCP and asyncio. This runs on the Android device itself, listens for HTTP requests, and translates them into Frida commands.
Client: Any HTTP client can interact with the server. The project was designed with tooling like 5ire in mind, allowing generative AI agents to interact with the instrumented device.
Streamable HTTP Transport: The server uses a streamable HTTP transport instead of a simpler stdio - based one. This was a deliberate choice to allow for multiple, concurrent connections, paving the way for more complex Agent - to - Agent (A2A) communication scenarios between multiple devices.
On - Device Script Bundling with esbuild: Frida versions 17+ require JavaScript to be minified or bundled. As frida - compile proved difficult to run directly on Android, this project uses esbuild as a lightweight alternative. The server automatically handles the process of writing JS code to a temporary file, bundling it with esbuild, and loading the result into the target process.
Manally Compiled Frida Version: The project currently depends on manually compiling the latest Frida client on - device. This is due to unstable C - bindings in the frida - python library. The workaround is to manually hijack the internal toolchain associated with frida - core and supply Termux - native tooling.

📚 Documentation

Android

Native tooling upgrade: Since I have a manual build technique for Frida I can just drop esbulid and just install frida - tools over Frida so frida - compile can be used instead of esbuild, so planning on releasing that for a cleaner build. This way we can just call all our favorite frida tools on - device XD

iOS

iOS rootless jailbreak support: I went on a truly unhinged and nightmarish foray into compiler hell, but I have a (mostly) working version that I tested on my rootless jailbroken iPhone X running iOS 16.7.12 almost ready for release! :3
Python3.12: This will feature a custom - compiled Python 3.12, a version not even available yet via Procursus repo. It also includes a suite of custom - compiled Python packages patched specifically for rootless environments. This was necessary imo to bring the full power of fastmcp to iOS.
Nodeless design: Node.js is not necessary. Supports (only) ObjC for on - the - fly compilation.

📄 License

This project is a networked evolution of the original [FridaMCP](https://github.com/dnakov/frida - mcp) by Daniel Nakov. While the original project pioneered the use of Frida as an MCP server over stdio, FridaC2MCP adapts this concept for remote, multi - device C2 environments using Streamable HTTP and modern Frida 17 bundling.

⚠️ Important Note

This is a rough draft and a proof - of - concept. It lacks proper session management, graceful error handling, and, most importantly, any form of security. All communication is unencrypted and unauthenticated. Use at your own risk and only in secure, isolated network environments.