CipherBridge: a proxy chain that decrypts app traffic so you can edit plaintext in Burp

Editing plaintext when the traffic is encrypted

CipherBridge is a visual decryption framework aimed at authorized app and web reverse-engineering and penetration testing. The README describes the recurring problem it solves: during app reversing and interface testing, request bodies are encrypted with AES, DES or SM4, parameters and headers carry MD5, SHA256 or HMAC signatures, and everything Burp Suite captures is ciphertext you cannot simply edit and replay.

The user is a security tester with authorization to assess an app or web target whose traffic is encrypted, who wants to modify requests in Burp without manually decrypting and re-encrypting each one. This is a tool for authorized testing, and its whole design assumes you have permission to intercept and modify the target's traffic.

The distinguishing approach is a local proxy chain. CipherBridge inserts a browser-or-app to decrypt-endpoint to Burp to encrypt-endpoint to server chain, so you edit plaintext inside Burp while the two ends automatically decrypt incoming and re-encrypt outgoing traffic. It is currently at version 5.0, and the repository ships no license, which bounds reuse.

How the decrypt-Burp-encrypt chain works

The mechanism is the proxy chain itself, and it is what makes encrypted targets testable in the normal Burp workflow. Incoming ciphertext hits the decrypt endpoint and becomes plaintext before Burp, so a tester sees and edits readable requests; the edited plaintext then passes through the encrypt endpoint, which re-applies the target's encryption before the request reaches the server. The tester works entirely in plaintext while the target still receives valid ciphertext.

CipherBridge generates the code that does this. The README says it produces a mitmdump plugin you can load directly with `mitmdump -s`, configured through per-project YAML profiles, and it supports visual configuration of AES, DES, 3DES, SM4 and RSA flows plus encoding recognition for Base64, Hex and JWT. Version 5.0 adds a Bypass Hook that rewrites a chosen encryption or hash path to an identity function so plaintext reaches Burp, then a one-click generate-encryption step, and a Burp extension in `burp_ext/` for bridging and a right-click send-to-CipherBridge action.

The README is candid about a real constraint of this approach: for irreversible steps, when a path is only Hash or HMAC, the generate-decryption action explicitly warns, because a hash cannot be reversed. That honesty about what cannot be decrypted is the correct behavior for a tool that otherwise automates a lot of crypto plumbing.

Installing and running it

CipherBridge installs as a Python project. The README's setup clones the repository, installs dependencies, installs a Chromium for its browser features, and runs the GUI:

git clone https://github.com/CuriousLearnerDev/CipherBridge.git
cd CipherBridge

pip install -r requirements.txt
playwright install chromium

python gui.py

Once a project is configured, the generated plugin can be loaded straight into mitmdump, or the framework mode run with a project selected by environment variable:

mitmdump -s plugins/myapp/plugin.py -p 8083

The README also documents a framework mode that sets a `PROFILE` environment variable and loads `main.py`, so a tester can switch between projects. Configuration lives in `profiles/{name}.yaml` and generated plugins under `plugins/{name}/`, with a `state.json` holding the visual step and parser state. Beyond the PyQt GUI, version 5.0 adds a Vue and Electron web version that starts and stops the proxy through a local FastAPI, giving a desktop UI alongside the Qt one. There are also browser and Burp extensions loaded from `browser_ext/` and `burp_ext/`.

The limitations: authorization, irreversible crypto, and no license

The first limitation is the one that governs use: CipherBridge is a tool for authorized testing. Intercepting, decrypting and modifying an application's traffic is something you do against targets you are permitted to assess, and using it otherwise is outside its intended, legitimate scope. The tool assumes you already hold that authorization.

The technical limitation the README itself surfaces is that hashes and HMACs are one-way. CipherBridge can bridge reversible encryption like AES or SM4, but for a Hash or HMAC step it warns rather than pretending to decrypt, and the Bypass Hook's identity-rewrite approach is the workaround for getting plaintext past such a step. A tester should understand which parts of a target's protection are reversible and which require the bypass approach, because the tool cannot invert a hash.

The most consequential gap is legal: the repository ships no license. Under default copyright the author retains all rights, so despite being public, CipherBridge cannot be safely redistributed or built upon until a license is added. The project is actively developed, with a dated changelog through version 5.0 (2026-08-22), so it is not stale, but the license question is unresolved for any use beyond running it yourself.

Against manual decryption scripts or a raw Burp extension

The alternatives are writing your own decryption and re-encryption scripts for each target, or building a bespoke Burp extension. Hand-rolled scripts give full control but must be rewritten per app and per algorithm, which is exactly the repetitive work CipherBridge automates. A raw Burp extension can decrypt in place but you build the crypto handling and the bidirectional flow yourself.

CipherBridge's difference is that it provides the whole visual pipeline, algorithm configuration for AES, DES, 3DES, SM4 and RSA, encoding recognition, generated mitmdump plugins, the bypass hook and Burp integration, so a tester assembles a decrypt-Burp-encrypt chain through a GUI rather than code. The cost is that it is a large, unlicensed dual-use tool you must trust and are responsible for using lawfully. Choose hand-written scripts when you have one target and want a minimal, auditable solution. Choose a bespoke extension if you need tight Burp integration and will build it. Choose CipherBridge when you regularly test encrypted apps with authorization and want a reusable visual framework that removes the per-target crypto plumbing, understanding the license is unresolved.

No license, active development, and where to start

The absence of a license is the first thing to settle. As shipped, CipherBridge is public and runnable but not reusable in a legal sense, so anyone wanting to redistribute or build on it should ask the author to add a license. The changelog shows steady work through version 5.0, including UI polish, the bypass hook, the Vue/Electron web version and applet-decompilation features, so the project is being actively worked on.

Maintenance-wise, the tool depends on mitmproxy (for the generated `mitmdump` plugins), Playwright's Chromium, and either PyQt or the Vue/Electron front end, so a working setup is that stack plus the project. Projects export and import as `.cbproj.zip` archives, which is how configurations move between machines.

The concrete first step, on a target you are authorized to test, is to stand up the chain and confirm the round-trip before relying on it: install with the README's clone, `pip install -r requirements.txt` and `playwright install chromium`, run `python gui.py`, configure one project's AES or SM4 flow, and verify that plaintext appears in Burp and that your edited request re-encrypts to something the server accepts. Confirm the Hash/HMAC warning behavior on any signature paths, since those are where the tool tells you it cannot decrypt.

Editorial conclusion

Use CipherBridge when you regularly perform authorized security testing on apps whose traffic is encrypted and you want a reusable visual framework that builds a decrypt-Burp-encrypt proxy chain, so you edit plaintext in Burp while both ends handle AES, SM4, RSA and encoding automatically. It is the wrong tool for anything you are not authorized to test, and it cannot reverse Hash or HMAC steps, warning instead and offering a bypass hook. Note the repository ships no license, so resolve that before redistributing or adapting it. Start on an authorized target by installing via the README's clone plus pip install and playwright install chromium, run python gui.py, and verify plaintext reaches Burp and re-encrypts to a request the server accepts.

Frequently asked questions

Official sources

1. CuriousLearnerDev/CipherBridge on GitHub
2. Issues
3. README
4. Releases