← Quay lại blog
RUENZHESARPTDEFRJAKOITTRIDVIFAHI

mitmproxy cho lập trình viên: chặn và phân tích lưu lượng HTTPS với ví dụ mã Python

mitmproxy là công cụ mạnh mẽ để chặn và phân tích lưu lượng HTTPS. Chúng tôi sẽ xem xét cách cài đặt, cấu hình chứng chỉ SSL, viết kịch bản và các kịch bản thực tế.

📅5 tháng 8, 2026
```html

Bạn đang gỡ lỗi ứng dụng di động và không hiểu những yêu cầu nào được gửi đến máy chủ? Bạn cần kiểm tra hành vi của API dưới các điều kiện khác nhau hoặc bắt giữ phản hồi và thay đổi dữ liệu ngay lập tức? mitmproxy giải quyết tất cả những vấn đề này — đây là công cụ miễn phí mã nguồn mở cho phép bạn kiểm soát hoàn toàn lưu lượng HTTP và HTTPS giữa khách hàng và máy chủ.

Mitmproxy là gì và tại sao nó cần thiết cho nhà phát triển

mitmproxy là một proxy MITM (Man-In-The-Middle Proxy) tương tác mã nguồn mở, được viết bằng Python. Nó hoạt động như một trung gian giữa ứng dụng của bạn và máy chủ: bắt giữ tất cả các yêu cầu và phản hồi, cho phép bạn xem, thay đổi, phát lại và lưu trữ chúng.

Điểm khác biệt chính của mitmproxy so với các máy chủ proxy thông thường là khả năng làm việc với lưu lượng HTTPS được mã hóa. Công cụ này tự động tạo ra các chứng chỉ SSL cho mỗi miền, cho phép giải mã lưu lượng ngay lập tức mà không làm gián đoạn hoạt động của ứng dụng.

Dưới đây là những nhiệm vụ điển hình mà các nhà phát triển giải quyết với mitmproxy:

  • Gỡ lỗi API — bạn thấy các yêu cầu và phản hồi chính xác, bao gồm tiêu đề, nội dung, mã trạng thái.
  • Kỹ thuật đảo ngược — phân tích cách các ứng dụng và dịch vụ bên thứ ba hoạt động.
  • Kiểm tra — thay thế phản hồi của máy chủ để kiểm tra các trường hợp biên.
  • Tự động hóa — viết kịch bản để sửa đổi lưu lượng theo điều kiện.
  • Ghi lại và phát lại — lưu phiên và phát lại nó mà không cần máy chủ thực.
  • Phân tích bảo mật — kiểm tra xem ứng dụng có gửi dữ liệu không cần thiết hay không.

Quan trọng cần hiểu

mitmproxy là công cụ dành cho việc kiểm tra và phát triển hợp pháp. Chỉ sử dụng nó để phân tích lưu lượng của các ứng dụng mà bạn phát triển hoặc có quyền kiểm tra. Bắt giữ lưu lượng của người khác mà không có sự cho phép là vi phạm pháp luật.

Công cụ này có ba phiên bản: giao diện tương tác trên console mitmproxy, giao diện web mitmweb và tiện ích dòng lệnh mitmdump. Tất cả ba công cụ sử dụng một lõi và hỗ trợ các kịch bản Python.

Cài đặt mitmproxy trên Windows, macOS và Linux

mitmproxy có thể được cài đặt theo nhiều cách khác nhau. Chúng tôi khuyên bạn nên sử dụng pip — điều này đảm bảo phiên bản mới nhất và dễ dàng cập nhật.

Cài đặt qua pip (cách phổ biến)

Cần có Python 3.9 hoặc mới hơn. Kiểm tra phiên bản Python:

python --version
# hoặc
python3 --version

Cài đặt mitmproxy:

pip install mitmproxy

Sau khi cài đặt, kiểm tra:

mitmproxy --version
# Phải hiển thị: mitmproxy 10.x.x

Cài đặt qua trình quản lý gói

macOS (Homebrew):

brew install mitmproxy

Linux (Ubuntu/Debian):

sudo apt install mitmproxy
# hoặc qua snap cho phiên bản mới nhất:
sudo snap install mitmproxy

Windows: Tải xuống trình cài đặt từ trang web chính thức mitmproxy.org hoặc sử dụng pip trong PowerShell với quyền quản trị.

Khởi động và kiểm tra cơ bản

Mặc định, mitmproxy lắng nghe trên cổng 8080. Khởi động giao diện web để bắt đầu:

# Khởi động giao diện web trên cổng 8080
mitmweb

# Khởi động trên cổng khác
mitmweb --listen-port 9090

# Giao diện console
mitmproxy

Sau khi khởi động mitmweb, mở trình duyệt ở địa chỉ http://127.0.0.1:8081 — đây là giao diện web để xem lưu lượng. Proxy tự hoạt động trên cổng 8080.

Cấu hình chứng chỉ SSL để bắt giữ HTTPS

Bắt giữ lưu lượng HTTPS yêu cầu cài đặt chứng chỉ CA gốc của mitmproxy vào hệ thống hoặc trình duyệt. Nếu không có bước này, trình duyệt sẽ hiển thị cảnh báo về kết nối không an toàn, và nhiều ứng dụng sẽ từ chối hoạt động.

Cách hoạt động về mặt kỹ thuật

Khi khởi động lần đầu tiên, mitmproxy tự động tạo chứng chỉ CA gốc và lưu nó vào thư mục ~/.mitmproxy/. Khi khách hàng kết nối đến trang web HTTPS thông qua proxy, mitmproxy sẽ tạo chứng chỉ cho miền đó ngay lập tức, ký nó bằng CA của mình. Khách hàng sẽ tin tưởng chứng chỉ này nếu CA đã được thêm vào danh sách tin cậy — và việc giải mã diễn ra một cách minh bạch.

Cài đặt chứng chỉ vào hệ thống

Các chứng chỉ nằm trong ~/.mitmproxy/:

  • mitmproxy-ca-cert.pem — cho Linux/macOS
  • mitmproxy-ca-cert.cer — cho Windows
  • mitmproxy-ca-cert.p12 — cho 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: Nhấp đúp vào tệp mitmproxy-ca-cert.cer → «Cài đặt chứng chỉ» → «Máy tính cục bộ» → «Các trung tâm chứng nhận gốc đáng tin cậy».

Cài đặt trong trình duyệt Firefox

Firefox sử dụng kho lưu trữ chứng chỉ riêng. Đi tới: Cài đặt → Quyền riêng tư và bảo mật → Chứng chỉ → Xem chứng chỉ → Các trung tâm chứng nhận → Nhập. Chọn tệp mitmproxy-ca-cert.pem và đánh dấu «Tin tưởng khi xác thực các trang web».

Kiểm tra hoạt động

Cấu hình trình duyệt để sử dụng proxy 127.0.0.1:8080 và mở bất kỳ trang web HTTPS nào. Trong giao diện mitmweb, bạn sẽ thấy lưu lượng đã được giải mã. Ngoài ra — mở http://mitm.it qua proxy đã cấu hình: mitmproxy sẽ hiển thị hướng dẫn cài đặt chứng chỉ cho nền tảng của bạn.

Ba giao diện: mitmproxy, mitmweb và mitmdump

Gói mitmproxy bao gồm ba tiện ích với các giao diện khác nhau cho các kịch bản làm việc khác nhau. Hiểu sự khác biệt sẽ giúp bạn chọn công cụ phù hợp cho từng nhiệm vụ.

Tiện ích Giao diện Khi nào sử dụng Đặc điểm
mitmproxy TUI trên console Gỡ lỗi tương tác trong terminal Cần terminal hỗ trợ màu sắc, bộ lọc mạnh mẽ
mitmweb Trình duyệt web Phân tích lưu lượng trực quan Giao diện thân thiện, hỗ trợ bộ lọc, xuất khẩu
mitmdump CLI (stdout) Kịch bản, CI/CD, tự động hóa Không tương tác, xuất ra tệp hoặc pipe

Các cờ khởi động hữu ích

# Ghi lại lưu lượng vào tệp
mitmdump -w traffic.dump

# Phát lại lưu lượng đã ghi
mitmdump -r traffic.dump

# Lọc: chỉ yêu cầu đến một miền cụ thể
mitmproxy --filter "~d api.example.com"

# Khởi động ở chế độ proxy trong suốt
mitmproxy --mode transparent

# Khởi động như một proxy upstream (chuỗi proxy)
mitmproxy --mode upstream:http://upstream-proxy:8080

# Chỉ định cổng cụ thể
mitmweb --listen-port 9090 --web-port 9091

# Khởi động với kịch bản
mitmproxy -s my_script.py

Cú pháp bộ lọc của mitmproxy

mitmproxy hỗ trợ ngôn ngữ bộ lọc mạnh mẽ để chọn các yêu cầu cần thiết:

# ~d — bộ lọc theo miền
~d api.example.com

# ~u — bộ lọc theo URL (regex)
~u /api/v2/users

# ~m — bộ lọc theo phương thức HTTP
~m POST

# ~s — chỉ phản hồi
~s ~c 404

# ~c — bộ lọc theo mã trạng thái
~c 500

# Kết hợp (AND)
~d api.example.com & ~m POST

# Kết hợp (OR)
~c 404 | ~c 500

# NOT
!~d static.example.com

Viết kịch bản Python: bắt giữ và sửa đổi lưu lượng

Kịch bản là sức mạnh chính của mitmproxy. Với chúng, bạn có thể tự động thay đổi các yêu cầu và phản hồi, ghi lại dữ liệu theo định dạng mong muốn, mô phỏng lỗi máy chủ và nhiều hơn nữa. Các kịch bản được viết bằng Python và sử dụng mô hình sự kiện.

Các sự kiện chính (hooks)

Hook Khi nào được gọi Đối tượng
request Nhận yêu cầu từ khách hàng flow.request
response Nhận phản hồi từ máy chủ flow.response
error Lỗi kết nối flow.error
tls_start_client Bắt đầu quá trình bắt tay TLS với khách hàng tls_start

Ví dụ 1: ghi lại yêu cầu vào tệp

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

def request(flow: mitmproxy.http.HTTPFlow) -> None:
    """Ghi lại mỗi yêu cầu vào tệp JSON."""
    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:
    """Ghi lại các phản hồi với mã lỗi."""
    if flow.response.status_code >= 400:
        print(f"[ERROR] {flow.request.method} {flow.request.pretty_url} "
              f"-> {flow.response.status_code}")

Khởi động kịch bản:

mitmproxy -s logger.py

Ví dụ 2: sửa đổi yêu cầu — thay thế tiêu đề

# modify_headers.py
from mitmproxy import http

def request(flow: http.HTTPFlow) -> None:
    """Thay thế User-Agent và thêm tiêu đề tùy chỉnh."""
    if "api.example.com" in flow.request.pretty_host:
        # Thay thế User-Agent
        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"
        )
        # Thêm tiêu đề xác thực
        flow.request.headers["X-Custom-Token"] = "test-token-12345"
        # Xóa tiêu đề
        if "X-Debug-Info" in flow.request.headers:
            del flow.request.headers["X-Debug-Info"]

Ví dụ 3: thay thế phản hồi của máy chủ (mock)

# mock_response.py
from mitmproxy import http
import json

def request(flow: http.HTTPFlow) -> None:
    """Bắt giữ yêu cầu và trả về phản hồi mock, không gọi đến máy chủ."""
    if flow.request.pretty_url.endswith("/api/v1/user/profile"):
        # Tạo phản hồi mock
        mock_data = {
            "id": 42,
            "name": "Test User",
            "email": "[email protected]",
            "premium": True  # Kiểm tra chức năng premium
        }
        flow.response = http.Response.make(
            200,  # Mã trạng thái
            json.dumps(mock_data),  # Nội dung phản hồi
            {"Content-Type": "application/json"}  # Tiêu đề
        )

def response(flow: http.HTTPFlow) -> None:
    """Sửa đổi phản hồi thực tế từ máy chủ."""
    if "/api/v1/products" in flow.request.pretty_url:
        try:
            data = json.loads(flow.response.text)
            # Thêm trường vào mỗi sản phẩm
            for product in data.get("items", []):
                product["debug_info"] = "intercepted"
            flow.response.text = json.dumps(data)
        except (json.JSONDecodeError, KeyError):
            pass

Ví dụ 4: mô phỏng kết nối chậm và lỗi

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

def response(flow: http.HTTPFlow) -> None:
    """Kỹ thuật hỗn loạn: độ trễ và lỗi ngẫu nhiên để kiểm tra."""
    # Thêm độ trễ ngẫu nhiên từ 0 đến 2 giây
    if "api.example.com" in flow.request.pretty_host:
        delay = random.uniform(0, 2.0)
        time.sleep(delay)

    # 10% xác suất phản hồi 503
    if random.random() < 0.1:
        flow.response = http.Response.make(
            503,
            json.dumps({"error": "Service Unavailable"}),
            {"Content-Type": "application/json"}
        )

Bắt giữ lưu lượng của các ứng dụng di động

Phân tích lưu lượng của các ứng dụng di động là một trong những nhiệm vụ thường gặp khi sử dụng mitmproxy. Điều này đặc biệt hữu ích khi thực hiện kỹ thuật đảo ngược API của các ứng dụng di động hoặc kiểm tra ứng dụng của chính bạn trên thiết bị thực.

Cấu hình trên Android

Bước 1. Đảm bảo rằng điện thoại và máy tính nằm trên cùng một mạng Wi-Fi.

Bước 2. Khởi động mitmproxy trên máy tính:

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

Bước 3. Trên Android: Cài đặt → Wi-Fi → giữ mạng → Thay đổi mạng → Nâng cao → Proxy → Thủ công. Nhập IP của máy tính và cổng 8080.

Bước 4. Cài đặt chứng chỉ trên Android: mở trình duyệt trên thiết bị, truy cập http://mitm.it và tải xuống chứng chỉ cho Android. Sau đó: Cài đặt → Bảo mật → Cài đặt chứng chỉ → Chứng chỉ CA.

Android 7+ và Certificate Pinning

Bắt đầu từ Android 7.0, các ứng dụng mặc định không tin tưởng các chứng chỉ CA của người dùng. Để bắt giữ lưu lượng của những ứng dụng này, bạn sẽ cần quyền root hoặc sửa đổi network_security_config.xml trong APK. Đối với các ứng dụng có SSL Pinning, hãy sử dụng Frida hoặc Xposed Framework để vượt qua kiểm tra chứng chỉ.

Cấu hình trên iOS

Bước 1. Cấu hình proxy tương tự như Android: Cài đặt → Wi-Fi → nhấn (i) bên cạnh mạng → Cấu hình proxy → Thủ công.

Bước 2. Mở Safari và truy cập http://mitm.it — tải xuống chứng chỉ cho iOS.

Bước 3. Cài đặt hồ sơ: Cài đặt → Hồ sơ đã tải → Cài đặt.

Bước 4. Bật tin tưởng chứng chỉ: Cài đặt → Chung → Về thiết bị → Tin tưởng chứng chỉ — bật công tắc cho mitmproxy.

Bắt giữ lưu lượng của một ứng dụng cụ thể qua Python

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

# Các miền của ứng dụng quan tâm
TARGET_DOMAINS = ["api.myapp.com", "cdn.myapp.com"]

def response(flow: http.HTTPFlow) -> None:
    """Phân tích lưu lượng của ứng dụng di động."""
    host = flow.request.pretty_host

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

    # Trích xuất các phản hồi JSON
    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

    # Tìm kiếm token trong tiêu đề yêu cầu
    auth_header = flow.request.headers.get("authorization", "")
    if auth_header:
        print(f"[AUTH] Token found: {auth_header[:50]}...")

Chuỗi proxy: mitmproxy + upstream-proxy

Một trong những kịch bản mạnh mẽ là sử dụng mitmproxy kết hợp với một máy chủ proxy bên ngoài. Điều này cho phép bạn đồng thời bắt giữ và phân tích lưu lượng (qua mitmproxy) và chuyển hướng nó qua địa chỉ IP bên ngoài (qua upstream-proxy). Sơ đồ này được sử dụng khi kiểm tra các API phụ thuộc vào địa lý hoặc khi phát triển các ứng dụng phải hoạt động qua proxy.

Chế độ upstream proxy

# Chuyển hướng tất cả lưu lượng qua upstream HTTP-proxy
mitmproxy --mode upstream:http://proxy-host:port

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

# Với xác thực
mitmproxy --mode upstream:http://user:password@proxy-host:port

# Qua mitmweb với upstream
mitmweb --mode upstream:http://proxy-host:port

Trong chế độ này, mitmproxy nhận các yêu cầu cục bộ, giải mã HTTPS, cho phép bạn phân tích và sửa đổi chúng, và sau đó chuyển tiếp qua proxy bên ngoài. Điều này đặc biệt thuận tiện khi kiểm tra các API chỉ có sẵn từ các khu vực cụ thể.

Đối với những nhiệm vụ như vậy, proxy cư trú là lựa chọn tốt — chúng có địa chỉ IP thực của người dùng từ các quốc gia cần thiết, cho phép kiểm tra chính xác các phản hồi API phụ thuộc vào địa lý.

Chọn upstream-proxy động trong kịch bản

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

# Danh sách proxy để luân phiên
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:
    """Luân phiên upstream-proxy cho mỗi yêu cầu."""
    global proxy_index

    # Chuyển hướng yêu cầu đến API qua các proxy khác nhau
    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"Using proxy: {proxy_url} for {flow.request.pretty_url}")

Proxy trong suốt (transparent mode)

Trong chế độ trong suốt, ứng dụng không biết rằng lưu lượng của nó đang bị bắt giữ — không cần cấu hình proxy trong cài đặt. Điều này yêu cầu cấu hình iptables/pf ở cấp độ hệ điều hành: 

# Khởi động ở chế độ transparent
mitmproxy --mode transparent --listen-port 8080

# Cấu hình iptables để chuyển hướng lưu lượng (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

Các kịch bản ứng dụng thực tế mitmproxy

Hãy xem xét các nhiệm vụ cụ thể mà các nhà phát triển giải quyết với mitmproxy trong các dự án thực tế.

Kịch bản 1: Kiểm tra API mà không thay đổi máy chủ

Giả sử: bạn cần kiểm tra cách frontend xử lý phản hồi với mảng dữ liệu rỗng hoặc lỗi xác thực 401, nhưng việc tái tạo điều này trên máy chủ thử nghiệm là khó khăn. mitmproxy cho phép thay thế phản hồi ngay lập tức: 

# test_edge_cases.py
from mitmproxy import http
import json

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

    # Kiểm tra: danh sách sản phẩm rỗng
    if "/api/products" in url and "test_empty=1" in url:
        flow.response.text = json.dumps({"items": [], "total": 0})

    # Kiểm tra: token đã hết hạn
    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"}
        )

    # Kiểm tra: vượt quá giới hạn yêu cầu
    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"}
        )

Kịch bản 2: Ghi lại và phát lại phiên

Hữu ích cho việc tạo các fixture thử nghiệm hoặc trình diễn chức năng mà không cần máy chủ thực: 

# Ghi lại phiên vào tệp
mitmdump -w session.dump --filter "~d api.example.com"

# Phát lại phiên đã ghi (offline)
mitmdump -r session.dump

# Chuyển đổi sang định dạng HAR để phân tích
mitmdump -r session.dump --flow-detail 3 > session.txt

Kịch bản 3: Tài liệu API tự động

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

# Từ điển để tích lũy thông tin về các endpoint
endpoints = defaultdict(lambda: {"methods": set(), "status_codes": set(),
                                  "request_fields": set(), "response_fields": set()})

def _extract_fields(data, prefix=""):
    """Trích xuất các trường từ JSON một cách đệ quy."""
    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

    # Chuẩn hóa URL (loại bỏ ID)
    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)

    # Trích xuất các trường yêu cầu
    if flow.request.text:
        try:
            req_data = json.loads(flow.request.text)
            ep["request_fields"].update(_extract_fields(req_data))
        except json.JSONDecodeError:
            pass

    # Trích xuất các trường phản hồi
    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():
    """Xuất tài liệu khi hoàn thành."""
    print("\n=== TÀI LIỆU API ===\n")
    for endpoint, info in sorted(endpoints.items()):
        print(f"Endpoint: {endpoint}")
        print(f"  Mã trạng thái: {sorted(info['status_codes'])}")
        if info["request_fields"]:
            print(f"  Trường yêu cầu: {sorted(info['request_fields'])}")
        if info["response_fields"]:
            print(f"  Trường phản hồi: {sorted(info['response_fields'])}")
        print()

Kịch bản 4: Kiểm tra phản hồi phụ thuộc vào địa lý

Khi phát triển các ứng dụng với nội dung theo khu vực, điều quan trọng là kiểm tra cách API phản hồi với các yêu cầu từ các quốc gia khác nhau. Để làm điều này, mitmproxy được khởi động ở chế độ upstream với proxy từ các trung tâm dữ liệu từ các khu vực cần thiết — đây là cách nhanh chóng và đáng tin cậy để mô phỏng các yêu cầu từ các quốc gia cụ thể. 

# geo_test.py
from mitmproxy import http

def response(flow: http.HTTPFlow) -> None:
    """Ghi lại các tiêu đề và dữ liệu phụ thuộc vào địa lý."""
    # Xem nội dung mà máy chủ trả về
    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}")

    # Tìm kiếm các đề cập đến tiền tệ và ngôn ngữ trong phản hồi
    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}")

Kịch bản 5: Sử dụng mitmproxy trong CI/CD

mitmdump rất phù hợp cho các bài kiểm tra tích hợp trong pipeline CI/CD — nó được khởi động như một quá trình nền, ghi lại lưu lượng và kết thúc cùng với các bài kiểm tra: 

#!/bin/bash
# ci_test.sh

# Khởi động mitmdump trong nền
mitmdump -w test_traffic.dump -s ci_assertions.py &
MITM_PID=$!

# Để proxy có thời gian khởi động
sleep 1

# Khởi động các bài kiểm tra với proxy
export HTTP_PROXY=http://127.0.0.1:8080
export HTTPS_PROXY=http://127.0.0.1:8080
pytest tests/integration/ -v

# Dừng mitmdump
kill $MITM_PID

# Phân tích lưu lượng đã ghi
mitmdump -r test_traffic.dump -s analyze_traffic.py

Kịch bản ci_assertions.py có thể kiểm tra rằng ứng dụng không thực hiện các yêu cầu không cần thiết, không truyền dữ liệu nhạy cảm dưới dạng không mã hóa và tuân thủ các hợp đồng API.

Kịch bản 6: Phân tích lưu lượng của trình phân tích

Khi phát triển các trình phân tích, mitmproxy giúp hiểu rõ các yêu cầu mà trình duyệt thực hiện khi tải trang — bao gồm các yêu cầu XHR/fetch đến API, mà không thấy trong mã nguồn HTML. Điều này cho phép truy cập trực tiếp đến API của trang web thay vì phân tích HTML. Khi phát triển các giải pháp như vậy, thường sử dụng proxy cư trú để luân phiên IP, nhằm tránh bị chặn khi thu thập dữ liệu.

Kết luận

mitmproxy là một trong những công cụ mạnh mẽ nhất trong kho vũ khí của nhà phát triển để làm việc với lưu lượng HTTP/HTTPS. Nó kết hợp các chức năng của một trình gỡ lỗi, môi trường thử nghiệm, tài liệu API và công cụ phân tích bảo mật. Ba giao diện — console, web và CLI — bao phủ tất cả các kịch bản: từ gỡ lỗi tương tác đến tự động hóa trong CI/CD.

```