# backtrip.web

> The backtrip decompiler — a Rust .NET & JVM decompiler — exposed as tools over the Model Context Protocol. Deterministic, stateless, no API key, no LLM.

The remote MCP endpoint lives at `https://backtrip.org/api/mcp` (Streamable HTTP transport, JSON-RPC 2.0). Any MCP client can connect; no authentication is required. Requests are rate-limited to 60/minute per IP and inputs are capped at 3 MB (base64-encoded).

## How it works

backtrip parses compiled binaries at the byte level — ECMA-335 PE/CLI metadata for .NET, JVMS class files and zip archives for Java — inside a stateless Vercel serverless function. The endpoint runs a TypeScript port of the backtrip parsing/disassembly engine, golden-tested byte-for-byte against the original Rust CLI on real .NET and Java fixtures. Input format is auto-detected from magic bytes: `MZ` → .NET assembly, `0xCAFEBABE` → JVM class file, `PK\x03\x04` → jar archive.

## Tools

### list_types

Inventory a binary.

- `.dll`/`.exe`: fully-qualified ECMA-335 type names (nested types as `Parent/Child`)
- `.class`: the dotted class name
- `.jar`: every class in the archive

```json
{ "name": "list_types", "arguments": { "file_base64": "<base64>" } }
```

Response: `{"format": "dotnet|java-class|jar", "type_count": N, "types": ["Shapes.Calculator", ...]}`

### decompile

Readable **Java source** from a JVM class file or jar archive: reconstructed
control flow (if/else, while, do-while, for, foreach, switch), string
concatenation from invokedynamic recipes, try/catch/finally, enums, generics
from Signature attributes, and LocalVariableTable parameter names.

```json
{ "name": "decompile", "arguments": { "file_base64": "<base64>", "type_filter": "Color" } }
```

`type_filter` (optional) selects one class for jar inputs. Response:
`{"format": "java-class|jar", "file_count": N, "files": [{"file_name": "demo_Sample.java", "source": "..."}]}`.
C# decompilation (.NET inputs) is not available yet — `disassemble` covers .NET.

### disassemble

Readable bytecode text for a binary.

- `.dll`/`.exe`: ildasm-style CIL (IL_XXXX labels, user strings from the #US heap, resolved type/method/field tokens, declared locals)
- `.class`/`.jar`: javap-style output (per-method listings, resolved constant-pool operands, exception tables, access flags)

```json
{ "name": "disassemble", "arguments": { "file_base64": "<base64>", "type_filter": "Calculator" } }
```

`type_filter` (optional) matches a simple or fully-qualified type/class name. Per-file output truncates at 256 KB with a `[truncated]` marker.

### metadata_json

Export a .NET assembly's type/method/field surface as structured JSON (the CLI's `--json` model). .NET only.

```json
{ "name": "metadata_json", "arguments": { "file_base64": "<base64>" } }
```

### detect_obfuscation

Scan a .NET assembly for obfuscation indicators — non-printable or unusual names, 100+-character identifiers, very large switch statements (control-flow flattening), single-decrypt-method string encryption — with per-finding severity (`high`/`medium`/`low`) plus a summary. .NET only.

```json
{ "name": "detect_obfuscation", "arguments": { "file_base64": "<base64>", "format": "json" } }
```

`format` also accepts `"text"` for a CLI-style report.

## Try it

Live playground (calls the same endpoint, nothing mocked): `https://backtrip.org/#playground`

## Links

- Upstream CLI (reference implementation, includes C#/Java source decompilation): https://github.com/yingkitw/backtrip
- crates.io: https://crates.io/crates/backtrip