Anything Analyzer: The Proxy That Watches, Decrypts, and Explains the Whole Stack

A reverse-engineering toolkit that merges Chromium capture, a custom MITM proxy, JS hooks, and MCP into one workflow for understanding private APIs and encrypted client logic.

10 min read • View on GitHub • More from Mouseww

A wide engraving-style scene shows two separate channels of water, one representing browser capture and one representing proxy traffic, merging through a lock gate into a single ledger of records. A small analyst figure studies the ledger while a subtle boundary at the gate suggests plaintext turning into encrypted payloads. The image explains that the tool does not just capture traffic, it unifies multiple sources into one analyzable timeline.
Browser and proxy traffic do not stay separate here. They merge into one captured record that can be read back by a human or an agent.
Key Takeaways

Anything Analyzer feels less like a proxy and more like a capture-to-meaning pipeline. That is the real story. It pulls browser traffic, MITM traffic, and JavaScript-level hooks into one local app, then hands the result to AI and MCP instead of leaving you with a pile of raw packets.

Why This Tool Feels Like a Category Shift

Most debugging tools stop at visibility. Burp, Fiddler, Charles, and Wireshark all give you a way to inspect traffic, but the burden of interpretation stays on you. Anything Analyzer tries to remove that second job by turning evidence into a structured dataset the machine can search.

Universal web protocol analyzer — 一款内嵌浏览器的桌面应用,通过 Chrome DevTools Protocol 实时捕获网络请求、JS Hook、存储变化,并借助 AI 进行智能协议分析。

Mouseww, Project Creator & Lead Maintainer · README.md at main · Mouseww/anything-analyzer

That framing matters because the repo is not aimed at one narrow workflow. It targets browser pages, desktop apps, terminal commands, scripts, and even mobile or IoT traffic routed through the proxy. The project is really about collapsing the gap between what was observed and what it means.

The Capture Trick: One Timeline for Browser and Proxy Traffic

The core capture idea is simple and useful. Data can arrive from the built-in Chromium browser through Chrome DevTools Protocol, or from the MITM proxy, but both paths are normalized through the same capture engine and written into one deterministic SQLite timeline.

A single pipeline turns browser events, proxy events, and hook events into one ordered record.

The useful part is not just that the app captures many sources. It also assigns sequence numbers so events that arrive out of order still land in a stable order. That matters when you are reconstructing what happened across a browser, a proxy, and a page lifecycle that keeps changing under you.

A close-up engraving-style scene shows a browser window with three hook points inserted into fetch, XHR, and crypto.subtle. Just beyond the hooks, a payload changes from handwritten text into sealed envelopes. The image explains that the tool captures plaintext at the transformation boundary before the encrypted version is sent onward.
The important moment is not the packet on the wire. It is the payload right before it becomes opaque.

How It Sees Through Obfuscation

This is the part that separates the repo from a standard proxy. The injected script hooks browser APIs like fetch, XHR, and crypto.subtle, so it can capture the plaintext before a site finishes encrypting or reshaping the request. In other words, it watches the transformation boundary, not just the aftermath.

That is why the app keeps re-injecting hooks on navigation. The page is not a stable environment, so the tool treats every navigation as a chance to restore observability. The result is a continuous view instead of a series of blind spots.

// Conceptual shape of the hook layer
window.fetch = async function (...args) {
  recordPlaintext(args);
  return originalFetch.apply(this, args);
};

const originalSubtleEncrypt = crypto.subtle.encrypt.bind(crypto.subtle);
crypto.subtle.encrypt = async function (...args) {
  recordEncryptionBoundary(args);
  return originalSubtleEncrypt(...args);
};

That hook layer is not there for novelty. It exists because many private APIs hide the interesting part inside client-side JavaScript. Once the app sees the request before encryption, it can preserve the evidence in a form that downstream analysis can actually use.

Why the MITM Proxy Is More Than a Checkbox Feature

The proxy is not just a networking accessory. It is part of the same capture system, with dynamic certificate generation so HTTPS traffic can be decrypted and added to the shared session record. That makes the app useful beyond the browser, which is why it can cover external scripts, desktop clients, and devices that never touch Chromium at all.

CapabilityAnything AnalyzerTraditional proxy
Certificate handlingGenerates certificates dynamically inside the workflowUsually requires manual setup and user intent
Traffic sourcesBrowser, proxy, hooks, and storage changesMostly network traffic only
Noise handlingFilters static assets before AI analysisLeaves filtering to the operator
OutputStructured data ready for analysis and MCP queriesRaw requests and responses for manual review

The filtering step is important. A proxy that captures everything is easy to build and hard to use. This repo tries to reduce the volume before analysis, so the AI layer sees signals rather than wallpaper.

AI as a Second Pass, Not a Replacement for Capture

The analysis pipeline is deliberately staged. Phase 1 filters and summarizes. Phase 2 goes deeper into the interesting chains, such as auth flows, token handling, or custom client-side encryption. That architecture avoids the trap of dumping a giant packet log into a prompt and hoping the model can rescue it.

传统工具各管一摊:DevTools 只看浏览器、Fiddler/Charles 只做代理、Wireshark 看不了 HTTPS。抓完包还得自己翻几百条请求,手动分析。 **Anything Analyzer 不一样 —— 全场景抓包 + AI 自动分析:**

Mouseww, Project Creator & Lead Maintainer · Repository: Mouseww/anything-analyzer

The point is not that AI replaces the operator. The point is that capture becomes clean enough for AI to help. That is a much stronger claim, and a much more plausible one.

MCP Changes the Role of the Tool

MCP is where the repo becomes more than a desktop utility. By acting as both an MCP client and server, Anything Analyzer lets external agents query captured sessions directly. The app is no longer just an instrument. It is also a data source that other tools can interrogate.

That changes the workflow in a practical way. A human can ask what happened, but an agent can also ask where the token was first generated, which request mutated it, and which client-side code path produced it. The database becomes a conversational surface.

Where It Fits Among Burp, Fiddler, Wireshark, and Browser Tools

ToolBest atWhat it lacks compared with Anything Analyzer
Burp SuiteManual security testing and interceptionBuilt-in agent-ready analysis and unified browser capture
FiddlerGeneral HTTP debuggingJS-level hooks and AI-assisted interpretation
WiresharkLow-level packet visibilityApplication-level understanding of encrypted web logic
browser_mcpBrowser control for agentsDeep traffic analysis and MITM capture
Anything AnalyzerCapture plus interpretation in one workflowIt is still a specialized reverse-engineering tool, not a universal browser replacement

That is the cleanest way to place it. Burp and Fiddler are inspection tools. Wireshark is a packet microscope. browser_mcp controls a browser for an agent. Anything Analyzer tries to convert the evidence into a machine-readable investigation workflow.