mitmproxy: Abfangen von HTTPS-Verkehr für Entwickler

```html

Debuggen Sie eine mobile Anwendung und verstehen nicht, welche Anfragen sie an den Server sendet? Müssen Sie das Verhalten der API unter verschiedenen Bedingungen testen oder die Antwort abfangen und die Daten zur Laufzeit ändern? mitmproxy löst all diese Aufgaben — es ist ein kostenloses Open-Source-Tool, das vollständige Kontrolle über HTTP- und HTTPS-Verkehr zwischen Client und Server ermöglicht.

Was ist mitmproxy und wozu benötigt es der Entwickler

mitmproxy ist ein interaktiver MITM-Proxy (Man-In-The-Middle Proxy) mit offenem Quellcode, der in Python geschrieben ist. Er fungiert als Vermittler zwischen Ihrer Anwendung und dem Server: er fängt alle Anfragen und Antworten ab, ermöglicht deren Ansicht, Änderung, Wiedergabe und Speicherung.

Der Hauptunterschied zwischen mitmproxy und herkömmlichen Proxy-Servern ist die Möglichkeit, mit verschlüsseltem HTTPS-Verkehr zu arbeiten. Das Tool generiert dynamisch SSL-Zertifikate für jede Domain, was es ermöglicht, den Verkehr in Echtzeit zu entschlüsseln, ohne die Funktionalität der Anwendung zu beeinträchtigen.

Hier sind typische Aufgaben, die Entwickler mit mitmproxy lösen:

API-Debugging — Sie sehen die genauen Anfragen und Antworten, einschließlich Header, Body und Statuscodes.
Reverse Engineering — Sie analysieren, wie Drittanbieteranwendungen und -dienste funktionieren.
Testing — Sie ändern die Serverantworten, um Grenzfälle zu überprüfen.
Automatisierung — Sie schreiben Skripte zur Modifikation des Verkehrs unter bestimmten Bedingungen.
Aufzeichnung und Wiedergabe — Sie speichern eine Sitzung und spielen sie ohne echten Server ab.
Sicherheitsanalyse — Sie überprüfen, ob die Anwendung unnötige Daten überträgt.

Wichtig zu verstehen

mitmproxy ist ein Tool für legales Testen und Entwickeln. Verwenden Sie es nur zur Analyse des Verkehrs von Anwendungen, die Sie entwickeln oder für die Sie das Recht haben, sie zu testen. Das Abfangen von fremdem Verkehr ohne Erlaubnis verstößt gegen das Gesetz.

Das Tool wird in drei Varianten geliefert: die interaktive Konsolenschnittstelle mitmproxy, die Webschnittstelle mitmweb und das Kommandozeilenwerkzeug mitmdump. Alle drei verwenden den gleichen Kern und unterstützen Python-Skripte.

Installation von mitmproxy auf Windows, macOS und Linux

mitmproxy kann auf verschiedene Arten installiert werden. Wir empfehlen die Verwendung von pip — dies gewährleistet die aktuelle Version und einfache Updates.

Installation über pip (universelle Methode)

Python 3.9 oder neuer ist erforderlich. Überprüfen Sie die Python-Version:

python --version
# oder
python3 --version

Installieren Sie mitmproxy:

pip install mitmproxy

Nach der Installation überprüfen Sie:

mitmproxy --version
# Sollte ausgeben: mitmproxy 10.x.x

Installation über Paketmanager

macOS (Homebrew):

brew install mitmproxy

Linux (Ubuntu/Debian):

sudo apt install mitmproxy
# oder über snap für die aktuelle Version:
sudo snap install mitmproxy

Windows: Laden Sie den Installer von der offiziellen Website mitmproxy.org herunter oder verwenden Sie pip in PowerShell mit Administratorrechten.

Start und grundlegende Überprüfung

Standardmäßig hört mitmproxy auf Port 8080. Starten Sie die Webschnittstelle, um zu beginnen:

# Starten der Webschnittstelle auf Port 8080
mitmweb

# Starten auf einem anderen Port
mitmweb --listen-port 9090

# Konsolenschnittstelle
mitmproxy

Nach dem Start von mitmweb öffnen Sie den Browser unter http://127.0.0.1:8081 — dies ist die Webschnittstelle zur Anzeige des Verkehrs. Der Proxy selbst läuft auf Port 8080.

Konfiguration von SSL-Zertifikaten zum Abfangen von HTTPS

Das Abfangen von HTTPS-Verkehr erfordert die Installation des mitmproxy-Wurzelzertifikats im System oder im Browser. Ohne diesen Schritt zeigt der Browser eine Warnung über eine unsichere Verbindung an, und viele Anwendungen werden überhaupt nicht funktionieren.

Wie es technisch funktioniert

Bei der ersten Ausführung erstellt mitmproxy automatisch ein Wurzel-CA-Zertifikat und speichert es im Verzeichnis ~/.mitmproxy/. Wenn sich ein Client über den Proxy mit einer HTTPS-Website verbindet, generiert mitmproxy in Echtzeit ein Zertifikat für diese Domain und signiert es mit seiner CA. Der Client vertraut diesem Zertifikat, wenn die CA zu den vertrauenswürdigen hinzugefügt wurde — und die Entschlüsselung erfolgt transparent.

Installation des Zertifikats im System

Die Zertifikate befinden sich in ~/.mitmproxy/:

mitmproxy-ca-cert.pem — für Linux/macOS
mitmproxy-ca-cert.cer — für Windows
mitmproxy-ca-cert.p12 — für iOS

macOS:

sudo security add-trusted-cert -d -r trustRoot \
  -k /Library/Keychains/System.keychain \
  ~/.mitmproxy/mitmproxy-ca-cert.pem

Linux (Ubuntu/Debian):

sudo cp ~/.mitmproxy/mitmproxy-ca-cert.pem \
  /usr/local/share/ca-certificates/mitmproxy.crt
sudo update-ca-certificates

Windows: Doppelklicken Sie auf die Datei mitmproxy-ca-cert.cer → „Zertifikat installieren“ → „Lokaler Computer“ → „Vertrauenswürdige Stammzertifizierungsstellen“.

Installation im Firefox-Browser

Firefox verwendet ein eigenes Zertifikatsspeicher. Gehen Sie zu: Einstellungen → Datenschutz und Sicherheit → Zertifikate → Zertifikate anzeigen → Zertifizierungsstellen → Importieren. Wählen Sie die Datei mitmproxy-ca-cert.pem aus und aktivieren Sie „Vertrauen für die Identifizierung von Websites“.

Überprüfung der Funktionalität

Konfigurieren Sie den Browser so, dass er den Proxy 127.0.0.1:8080 verwendet, und öffnen Sie eine beliebige HTTPS-Website. Im mitmweb-Interface sollten Sie den entschlüsselten Verkehr sehen. Alternativ — öffnen Sie http://mitm.it über den konfigurierten Proxy: mitmproxy zeigt Anweisungen zur Installation des Zertifikats für Ihre Plattform an.

Drei Schnittstellen: mitmproxy, mitmweb und mitmdump

Das mitmproxy-Paket umfasst drei Dienstprogramme mit unterschiedlichen Schnittstellen für verschiedene Arbeitsabläufe. Das Verständnis der Unterschiede hilft Ihnen, das richtige Werkzeug für jede Aufgabe auszuwählen.

Dienstprogramm	Schnittstelle	Wann verwenden	Besonderheiten
`mitmproxy`	Konsolen-TUI	Interaktives Debugging im Terminal	Benötigt ein Terminal mit Farbunterstützung, leistungsstarker Filter
`mitmweb`	Webbrowser	Visuelle Analyse des Verkehrs	Benutzerfreundliche UI, Unterstützung von Filtern, Export
`mitmdump`	CLI (stdout)	Skripte, CI/CD, Automatisierung	Keine Interaktivität, Ausgabe in Datei oder Pipe

Nützliche Startflags

# Verkehr in eine Datei aufzeichnen
mitmdump -w traffic.dump

# Aufzeichnung des gespeicherten Verkehrs wiedergeben
mitmdump -r traffic.dump

# Filterung: nur Anfragen an eine bestimmte Domain
mitmproxy --filter "~d api.example.com"

# Start im transparenten Proxy-Modus
mitmproxy --mode transparent

# Start als Upstream-Proxy (Proxy-Kette)
mitmproxy --mode upstream:http://upstream-proxy:8080

# Angabe eines bestimmten Ports
mitmweb --listen-port 9090 --web-port 9091

# Start mit Skript
mitmproxy -s my_script.py

Syntax der mitmproxy-Filter

mitmproxy unterstützt eine leistungsstarke Filtersprache zur Auswahl der gewünschten Anfragen:

# ~d — Filter nach Domain
~d api.example.com

# ~u — Filter nach URL (regex)
~u /api/v2/users

# ~m — Filter nach HTTP-Methode
~m POST

# ~s — nur Antworten
~s ~c 404

# ~c — Filter nach Statuscode
~c 500

# Kombination (UND)
~d api.example.com & ~m POST

# Kombination (ODER)
~c 404 | ~c 500

# NICHT
!~d static.example.com

Skripte in Python schreiben: Abfangen und Modifizieren von Verkehr

Skripte sind die Hauptsuperkraft von mitmproxy. Damit können Sie Anfragen und Antworten automatisch ändern, Daten im gewünschten Format protokollieren, Serverfehler simulieren und vieles mehr. Skripte werden in Python geschrieben und verwenden ein Ereignismodell.

Wichtige Ereignisse (Hooks)

Hook	Wann wird er aufgerufen	Objekt
`request`	Anfrage vom Client empfangen	`flow.request`
`response`	Antwort vom Server empfangen	`flow.response`
`error`	Verbindungsfehler	`flow.error`
`tls_start_client`	Beginn der TLS-Handschlag mit dem Client	`tls_start`

Beispiel 1: Protokollierung von Anfragen in eine Datei

# logger.py
import mitmproxy.http
import json
from datetime import datetime

def request(flow: mitmproxy.http.HTTPFlow) -> None:
    """Protokollieren Sie jede Anfrage in einer JSON-Datei."""
    log_entry = {
        "timestamp": datetime.now().isoformat(),
        "method": flow.request.method,
        "url": flow.request.pretty_url,
        "headers": dict(flow.request.headers),
        "body": flow.request.text if flow.request.text else None
    }
    with open("requests.log", "a") as f:
        f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")

def response(flow: mitmproxy.http.HTTPFlow) -> None:
    """Protokollieren Sie Antworten mit Fehlercode."""
    if flow.response.status_code >= 400:
        print(f"[ERROR] {flow.request.method} {flow.request.pretty_url} "
              f"-> {flow.response.status_code}")

Skript ausführen:

mitmproxy -s logger.py

Beispiel 2: Modifikation von Anfragen — Header ersetzen

# modify_headers.py
from mitmproxy import http

def request(flow: http.HTTPFlow) -> None:
    """Ersetzen Sie den User-Agent und fügen Sie einen benutzerdefinierten Header hinzu."""
    if "api.example.com" in flow.request.pretty_host:
        # User-Agent ersetzen
        flow.request.headers["User-Agent"] = (
            "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) "
            "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1"
        )
        # Hinzufügen des Autorisierungsheaders
        flow.request.headers["X-Custom-Token"] = "test-token-12345"
        # Header entfernen
        if "X-Debug-Info" in flow.request.headers:
            del flow.request.headers["X-Debug-Info"]

Beispiel 3: Serverantwort ersetzen (Mock)

# mock_response.py
from mitmproxy import http
import json

def request(flow: http.HTTPFlow) -> None:
    """Fangen Sie die Anfrage ab und geben Sie eine Mock-Antwort zurück, ohne den Server zu kontaktieren."""
    if flow.request.pretty_url.endswith("/api/v1/user/profile"):
        # Erstellen Sie eine Mock-Antwort
        mock_data = {
            "id": 42,
            "name": "Test User",
            "email": "[email protected]",
            "premium": True  # Testen der Premium-Funktionalität
        }
        flow.response = http.Response.make(
            200,  # Statuscode
            json.dumps(mock_data),  # Antworttext
            {"Content-Type": "application/json"}  # Header
        )

def response(flow: http.HTTPFlow) -> None:
    """Modifizieren Sie die echte Antwort des Servers."""
    if "/api/v1/products" in flow.request.pretty_url:
        try:
            data = json.loads(flow.response.text)
            # Fügen Sie ein Feld zu jedem Produkt hinzu
            for product in data.get("items", []):
                product["debug_info"] = "intercepted"
            flow.response.text = json.dumps(data)
        except (json.JSONDecodeError, KeyError):
            pass

Beispiel 4: Simulation einer langsamen Verbindung und Fehler

# chaos_testing.py
from mitmproxy import http
import time
import random

def response(flow: http.HTTPFlow) -> None:
    """Chaos Engineering: zufällige Verzögerungen und Fehler zum Testen."""
    # Fügen Sie eine zufällige Verzögerung von 0 bis 2 Sekunden hinzu
    if "api.example.com" in flow.request.pretty_host:
        delay = random.uniform(0, 2.0)
        time.sleep(delay)

    # 10% Wahrscheinlichkeit für eine 503-Antwort
    if random.random() < 0.1:
        flow.response = http.Response.make(
            503,
            json.dumps({"error": "Service Unavailable"}),
            {"Content-Type": "application/json"}
        )

Abfangen des Verkehrs von mobilen Anwendungen

Die Analyse des Verkehrs von mobilen Anwendungen ist eine der häufigsten Aufgaben bei der Verwendung von mitmproxy. Dies ist besonders nützlich beim Reverse Engineering von APIs mobiler Anwendungen oder beim Testen Ihrer eigenen Anwendung auf einem echten Gerät.

Konfiguration auf Android

Schritt 1. Stellen Sie sicher, dass das Telefon und der Computer im selben Wi-Fi-Netzwerk sind.

Schritt 2. Starten Sie mitmproxy auf dem Computer:

mitmweb --listen-host 0.0.0.0 --listen-port 8080

Schritt 3. Auf Android: Einstellungen → Wi-Fi → Netzwerk lange drücken → Netzwerk ändern → Erweitert → Proxy → Manuell. Geben Sie die IP des Computers und den Port 8080 ein.

Schritt 4. Installation des Zertifikats auf Android: Öffnen Sie den Browser auf dem Gerät, gehen Sie zu http://mitm.it und laden Sie das Zertifikat für Android herunter. Dann: Einstellungen → Sicherheit → Zertifikat installieren → CA-Zertifikat.

Android 7+ und Zertifikat-Pinning

Ab Android 7.0 vertrauen Anwendungen standardmäßig nicht benutzerdefinierten CA-Zertifikaten. Um den Verkehr solcher Anwendungen abzufangen, ist entweder Root-Zugriff erforderlich oder die Modifikation von network_security_config.xml in der APK. Für Anwendungen mit SSL-Pinning verwenden Sie Frida oder das Xposed Framework, um die Zertifikatsprüfung zu umgehen.

Konfiguration auf iOS

Schritt 1. Konfigurieren Sie den Proxy ähnlich wie auf Android: Einstellungen → Wi-Fi → auf (i) neben dem Netzwerk tippen → Proxy konfigurieren → Manuell.

Schritt 2. Öffnen Sie Safari und gehen Sie zu http://mitm.it — laden Sie das Zertifikat für iOS herunter.

Schritt 3. Installieren Sie das Profil: Einstellungen → Profil herunterladen → Installieren.

Schritt 4. Aktivieren Sie das Vertrauen in das Zertifikat: Einstellungen → Allgemein → Über → Vertrauen in Zertifikate — aktivieren Sie den Schalter für mitmproxy.

Abfangen des Verkehrs einer bestimmten Anwendung über Python

# mobile_app_analyzer.py
from mitmproxy import http
import json
import re

# Domains der interessierenden Anwendung
TARGET_DOMAINS = ["api.myapp.com", "cdn.myapp.com"]

def response(flow: http.HTTPFlow) -> None:
    """Analysieren Sie den Verkehr der mobilen Anwendung."""
    host = flow.request.pretty_host

    if not any(domain in host for domain in TARGET_DOMAINS):
        return

    # Extrahieren Sie JSON-Antworten
    content_type = flow.response.headers.get("content-type", "")
    if "application/json" in content_type:
        try:
            data = json.loads(flow.response.text)
            print(f"\n{'='*60}")
            print(f"URL: {flow.request.pretty_url}")
            print(f"Status: {flow.response.status_code}")
            print(f"Response: {json.dumps(data, indent=2, ensure_ascii=False)}")
        except json.JSONDecodeError:
            pass

    # Suchen Sie Tokens in den Anfrage-Headern
    auth_header = flow.request.headers.get("authorization", "")
    if auth_header:
        print(f"[AUTH] Token gefunden: {auth_header[:50]}...")

Proxy-Kette: mitmproxy + Upstream-Proxy

Ein leistungsstarkes Szenario ist die Verwendung von mitmproxy in Verbindung mit einem externen Proxy-Server. Dies ermöglicht es, den Verkehr gleichzeitig abzufangen und zu analysieren (über mitmproxy) und ihn über eine externe IP-Adresse zu leiten (über den Upstream-Proxy). Dieses Schema wird beim Testen von geoabhängigen APIs oder bei der Entwicklung von Anwendungen verwendet, die über einen Proxy arbeiten müssen.

Upstream-Proxy-Modus

# Leiten Sie den gesamten Verkehr über einen Upstream-HTTP-Proxy
mitmproxy --mode upstream:http://proxy-host:port

# Upstream-SOCKS5-Proxy
mitmproxy --mode upstream:socks5://proxy-host:port

# Mit Authentifizierung
mitmproxy --mode upstream:http://user:password@proxy-host:port

# Über mitmweb mit Upstream
mitmweb --mode upstream:http://proxy-host:port

In diesem Modus akzeptiert mitmproxy Anfragen lokal, entschlüsselt HTTPS, gibt Ihnen die Möglichkeit, sie zu analysieren und zu modifizieren, und leitet sie dann über einen externen Proxy weiter. Dies ist besonders nützlich beim Testen von APIs, die nur aus bestimmten Regionen zugänglich sind.

Für solche Aufgaben eignen sich residential Proxys gut — sie haben echte IP-Adressen von Haushaltsnutzern aus den benötigten Ländern, was es ermöglicht, geoabhängige API-Antworten korrekt zu testen.

Dynamische Auswahl des Upstream-Proxys im Skript

# dynamic_upstream.py
from mitmproxy import http
from mitmproxy.net.server_spec import ServerSpec

# Liste von Proxys zur Rotation
PROXY_LIST = [
    "http://proxy1.example.com:8080",
    "http://proxy2.example.com:8080",
    "http://proxy3.example.com:8080",
]

proxy_index = 0

def request(flow: http.HTTPFlow) -> None:
    """Rotation des Upstream-Proxys für jede Anfrage."""
    global proxy_index

    # Leiten Sie Anfragen an die API über verschiedene Proxys
    if "api.target.com" in flow.request.pretty_host:
        proxy_url = PROXY_LIST[proxy_index % len(PROXY_LIST)]
        proxy_index += 1
        flow.live.change_upstream_proxy_server(
            ServerSpec.from_url(proxy_url)
        )
        print(f"Verwende Proxy: {proxy_url} für {flow.request.pretty_url}")

Transparenter Proxy (transparent mode)

Im transparenten Modus weiß die Anwendung nicht, dass ihr Verkehr abgefangen wird — es ist keine Proxy-Konfiguration in den Einstellungen erforderlich. Dies erfordert die Konfiguration von iptables/pf auf Betriebssystemebene:

# Start im transparenten Modus
mitmproxy --mode transparent --listen-port 8080

# Konfiguration von iptables zur Umleitung des Verkehrs (Linux)
sudo iptables -t nat -A OUTPUT -p tcp --dport 80 -j REDIRECT --to-port 8080
sudo iptables -t nat -A OUTPUT -p tcp --dport 443 -j REDIRECT --to-port 8080

Praktische Anwendungsszenarien mit mitmproxy

Lassen Sie uns spezifische Aufgaben betrachten, die Entwickler mit mitmproxy in realen Projekten lösen.

Szenario 1: Testen der API ohne Änderung des Servers

Stellen Sie sich vor: Sie müssen überprüfen, wie das Frontend auf eine Antwort mit einem leeren Datenarray oder einen Autorisierungsfehler 401 reagiert, aber es ist schwierig, dies auf dem Testserver zu reproduzieren. mitmproxy ermöglicht es, die Antwort direkt zur Laufzeit zu ändern:

# test_edge_cases.py
from mitmproxy import http
import json

def response(flow: http.HTTPFlow) -> None:
    url = flow.request.pretty_url

    # Test: leere Produktliste
    if "/api/products" in url and "test_empty=1" in url:
        flow.response.text = json.dumps({"items": [], "total": 0})

    # Test: abgelaufenes Token
    if "/api/user" in url and "test_auth=1" in url:
        flow.response = http.Response.make(
            401,
            json.dumps({"error": "Token expired", "code": "AUTH_001"}),
            {"Content-Type": "application/json"}
        )

    # Test: Überschreitung des Anfrage-Limits
    if "/api/" in url and "test_rate=1" in url:
        flow.response = http.Response.make(
            429,
            json.dumps({"error": "Too Many Requests", "retry_after": 60}),
            {"Content-Type": "application/json",
             "Retry-After": "60"}
        )

Szenario 2: Aufzeichnung und Wiedergabe einer Sitzung

Nützlich für die Erstellung von Testfixtures oder die Demonstration von Funktionen ohne echten Server:

# Sitzung in eine Datei aufzeichnen
mitmdump -w session.dump --filter "~d api.example.com"

# Aufzeichnung der gespeicherten Sitzung (offline)
mitmdump -r session.dump

# Konvertierung in HAR-Format zur Analyse
mitmdump -r session.dump --flow-detail 3 > session.txt

Szenario 3: Automatische Dokumentation der API

# api_documenter.py
from mitmproxy import http
import json
from collections import defaultdict

# Wörterbuch zur Ansammlung von Informationen über Endpunkte
endpoints = defaultdict(lambda: {"methods": set(), "status_codes": set(),
                                  "request_fields": set(), "response_fields": set()})

def _extract_fields(data, prefix=""):
    """Rekursiv Felder aus JSON extrahieren."""
    fields = set()
    if isinstance(data, dict):
        for key, value in data.items():
            full_key = f"{prefix}.{key}" if prefix else key
            fields.add(full_key)
            fields.update(_extract_fields(value, full_key))
    elif isinstance(data, list) and data:
        fields.update(_extract_fields(data[0], prefix))
    return fields

def response(flow: http.HTTPFlow) -> None:
    if "api.example.com" not in flow.request.pretty_host:
        return

    # Normalisieren Sie die URL (ID entfernen)
    import re
    path = re.sub(r'/\d+', '/{id}', flow.request.path)
    endpoint = f"{flow.request.method} {path}"

    ep = endpoints[endpoint]
    ep["methods"].add(flow.request.method)
    ep["status_codes"].add(flow.response.status_code)

    # Extrahieren Sie die Felder der Anfrage
    if flow.request.text:
        try:
            req_data = json.loads(flow.request.text)
            ep["request_fields"].update(_extract_fields(req_data))
        except json.JSONDecodeError:
            pass

    # Extrahieren Sie die Felder der Antwort
    if flow.response.text:
        try:
            resp_data = json.loads(flow.response.text)
            ep["response_fields"].update(_extract_fields(resp_data))
        except json.JSONDecodeError:
            pass

def done():
    """Dokumentation beim Abschluss ausgeben."""
    print("\n=== API-DOKUMENTATION ===\n")
    for endpoint, info in sorted(endpoints.items()):
        print(f"Endpoint: {endpoint}")
        print(f"  Statuscodes: {sorted(info['status_codes'])}")
        if info["request_fields"]:
            print(f"  Anfragefelder: {sorted(info['request_fields'])}")
        if info["response_fields"]:
            print(f"  Antwortfelder: {sorted(info['response_fields'])}")
        print()

Szenario 4: Testen von geoabhängigen Antworten

Bei der Entwicklung von Anwendungen mit regionalem Inhalt ist es wichtig zu überprüfen, wie die API auf Anfragen aus verschiedenen Ländern reagiert. Dazu wird mitmproxy im Upstream-Modus mit Datacenter-Proxys aus den benötigten Regionen gestartet — dies ist eine schnelle und zuverlässige Möglichkeit, Anfragen aus bestimmten Ländern zu simulieren.

# geo_test.py
from mitmproxy import http

def response(flow: http.HTTPFlow) -> None:
    """Protokollieren Sie geoabhängige Header und Daten."""
    # Überprüfen Sie, welchen Inhalt der Server zurückgibt
    geo_headers = ["cf-ipcountry", "x-country", "x-geo-country"]
    for header in geo_headers:
        value = flow.response.headers.get(header)
        if value:
            print(f"[GEO] {header}: {value} | URL: {flow.request.pretty_url}")

    # Suchen Sie nach Erwähnungen von Währungen und Lokalisierungen in der Antwort
    if flow.response.text:
        import re
        currencies = re.findall(r'"currency":\s*"([A-Z]{3})"', flow.response.text)
        locales = re.findall(r'"locale":\s*"([a-z]{2}-[A-Z]{2})"', flow.response.text)
        if currencies:
            print(f"[CURRENCY] {currencies}")
        if locales:
            print(f"[LOCALE] {locales}")

Szenario 5: Verwendung von mitmproxy in CI/CD

mitmdump eignet sich hervorragend für Integrationstests in einem CI/CD-Pipeline — es wird als Hintergrundprozess gestartet, zeichnet den Verkehr auf und wird zusammen mit den Tests beendet:

#!/bin/bash
# ci_test.sh

# Starten Sie mitmdump im Hintergrund
mitmdump -w test_traffic.dump -s ci_assertions.py &
MITM_PID=$!

# Geben Sie dem Proxy Zeit zum Starten
sleep 1

# Führen Sie die Tests mit dem Proxy aus
export HTTP_PROXY=http://127.0.0.1:8080
export HTTPS_PROXY=http://127.0.0.1:8080
pytest tests/integration/ -v

# Stoppen Sie mitmdump
kill $MITM_PID

# Analysieren Sie den aufgezeichneten Verkehr
mitmdump -r test_traffic.dump -s analyze_traffic.py

Das Skript ci_assertions.py kann überprüfen, ob die Anwendung keine überflüssigen Anfragen sendet, keine sensiblen Daten unverschlüsselt überträgt und die API-Verträge einhält.

Szenario 6: Analyse des Verkehrs eines Parsers

Bei der Entwicklung von Parsern hilft mitmproxy zu verstehen, welche Anfragen der Browser beim Laden einer Seite stellt — einschließlich XHR/fetch-Anfragen an die API, die im HTML-Quellcode nicht sichtbar sind. Dies ermöglicht es, direkt auf die API der Website zuzugreifen, anstatt HTML zu parsen. Bei der Entwicklung solcher Lösungen werden häufig residential Proxys zur IP-Rotation verwendet, um Blockierungen beim Datensammeln zu vermeiden.

Fazit

mitmproxy ist eines der leistungsstärksten Tools im Arsenal eines Entwicklers für die Arbeit mit HTTP/HTTPS-Verkehr. Es vereint Funktionen eines Debuggers, Testumgebung, API-Dokumentators und Sicherheitsanalysetools. Die drei Schnittstellen — Konsole, Web und CLI — decken alle Szenarien ab: von interaktivem Debugging bis hin zur Automatisierung in CI/CD.