mitmproxy: 개발자를 위한 HTTPS 트래픽 가로채기

```html

모바일 애플리케이션을 디버깅하고 있으며 서버에 어떤 요청을 보내는지 이해하지 못하고 있습니까? 다양한 조건에서 API의 동작을 테스트하거나 응답을 가로채고 데이터를 즉시 변경해야 합니까? mitmproxy는 이러한 모든 문제를 해결합니다. 이는 클라이언트와 서버 간의 HTTP 및 HTTPS 트래픽을 완전히 제어할 수 있는 무료 오픈 소스 도구입니다.

mitmproxy란 무엇이며 개발자에게 필요한 이유

mitmproxy는 Python으로 작성된 오픈 소스 인터랙티브 MITM 프록시(Man-In-The-Middle Proxy)입니다. 이는 애플리케이션과 서버 간의 중개자로 작동하여 모든 요청과 응답을 가로채고, 이를 검토하고, 수정하고, 재생하고, 저장할 수 있게 해줍니다.

mitmproxy의 주요 차별점은 암호화된 HTTPS 트래픽을 처리할 수 있는 기능입니다. 이 도구는 각 도메인에 대한 SSL 인증서를 동적으로 생성하여 트래픽을 실시간으로 복호화할 수 있게 해주며, 애플리케이션의 작동을 방해하지 않습니다.

다음은 개발자들이 mitmproxy를 사용하여 해결하는 일반적인 문제들입니다:

API 디버깅 — 요청과 응답의 정확한 내용을 확인할 수 있습니다. 헤더, 본문, 상태 코드 포함.
리버스 엔지니어링 — 타사 애플리케이션 및 서비스의 작동 방식을 분석합니다.
테스트 — 서버의 응답을 변경하여 경계 사례를 확인합니다.
자동화 — 조건에 따라 트래픽을 수정하는 스크립트를 작성합니다.
세션 기록 및 재생 — 세션을 저장하고 실제 서버 없이 재생합니다.
보안 분석 — 애플리케이션이 불필요한 데이터를 전송하지 않는지 확인합니다.

중요한 점

mitmproxy는 합법적인 테스트 및 개발을 위한 도구입니다. 자신이 개발하거나 테스트할 권한이 있는 애플리케이션의 트래픽 분석에만 사용하세요. 허가 없이 타인의 트래픽을 가로채는 것은 법률을 위반합니다.

이 도구는 세 가지 버전으로 제공됩니다: 콘솔 인터랙티브 인터페이스 mitmproxy, 웹 인터페이스 mitmweb 및 명령줄 유틸리티 mitmdump. 이 세 가지는 동일한 코어를 사용하며 Python 스크립트를 지원합니다.

Windows, macOS 및 Linux에 mitmproxy 설치하기

mitmproxy는 여러 방법으로 설치할 수 있습니다. pip를 사용하는 것이 좋습니다. 이는 최신 버전과 간편한 업데이트를 보장합니다.

pip을 통한 설치 (범용 방법)

Python 3.9 이상이 필요합니다. Python 버전을 확인하세요:

python --version
# 또는
python3 --version

mitmproxy를 설치합니다:

pip install mitmproxy

설치 후 확인합니다:

mitmproxy --version
# 다음과 같은 출력이 나와야 합니다: mitmproxy 10.x.x

패키지 관리자를 통한 설치

macOS (Homebrew):

brew install mitmproxy

Linux (Ubuntu/Debian):

sudo apt install mitmproxy
# 또는 최신 버전을 위해 snap을 통해:
sudo snap install mitmproxy

Windows: 공식 웹사이트 mitmproxy.org에서 설치 프로그램을 다운로드하거나 PowerShell에서 관리자 권한으로 pip를 사용할 수 있습니다.

실행 및 기본 확인

기본적으로 mitmproxy는 포트 8080에서 수신 대기합니다. 작업을 시작하기 위해 웹 인터페이스를 실행합니다:

# 포트 8080에서 웹 인터페이스 실행
mitmweb

# 다른 포트에서 실행
mitmweb --listen-port 9090

# 콘솔 인터페이스
mitmproxy

mitmweb를 실행한 후, 브라우저를 열고 http://127.0.0.1:8081로 이동합니다. 이는 트래픽을 보기 위한 웹 인터페이스입니다. 프록시는 8080 포트에서 작동합니다.

HTTPS 가로채기를 위한 SSL 인증서 설정

HTTPS 트래픽을 가로채려면 mitmproxy의 루트 인증서를 시스템이나 브라우저에 설치해야 합니다. 이 단계를 수행하지 않으면 브라우저는 안전하지 않은 연결에 대한 경고를 표시하고 많은 애플리케이션은 아예 작동하지 않을 것입니다.

기술적으로 어떻게 작동하는가

mitmproxy를 처음 실행하면 자동으로 루트 CA 인증서를 생성하고 ~/.mitmproxy/ 디렉토리에 저장합니다. 클라이언트가 프록시를 통해 HTTPS 사이트에 연결할 때 mitmproxy는 해당 도메인에 대한 인증서를 실시간으로 생성하고 자신의 CA로 서명합니다. 클라이언트는 CA가 신뢰할 수 있는 목록에 추가된 경우 이 인증서를 신뢰하며, 복호화는 투명하게 이루어집니다.

시스템에 인증서 설치하기

인증서는 ~/.mitmproxy/에 있습니다:

mitmproxy-ca-cert.pem — Linux/macOS용
mitmproxy-ca-cert.cer — Windows용
mitmproxy-ca-cert.p12 — 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: mitmproxy-ca-cert.cer 파일을 두 번 클릭 → "인증서 설치" → "로컬 컴퓨터" → "신뢰할 수 있는 루트 인증 기관".

Firefox에서 인증서 설치하기

Firefox는 자체 인증서 저장소를 사용합니다. 다음으로 이동하세요: 설정 → 개인정보 보호 및 보안 → 인증서 → 인증서 보기 → 인증 기관 → 가져오기. mitmproxy-ca-cert.pem 파일을 선택하고 "웹사이트 식별 시 신뢰"를 체크하세요.

작동 확인하기

브라우저를 프록시 127.0.0.1:8080을 사용하도록 설정하고 아무 HTTPS 사이트를 열어보세요. mitmweb 인터페이스에서 복호화된 트래픽을 확인할 수 있어야 합니다. 대안으로, 설정된 프록시를 통해 http://mitm.it를 열어보세요: mitmproxy는 귀하의 플랫폼에 대한 인증서 설치 지침을 보여줄 것입니다.

세 가지 인터페이스: mitmproxy, mitmweb 및 mitmdump

mitmproxy 패키지는 다양한 작업 시나리오에 맞는 세 가지 유틸리티를 포함합니다. 각 도구의 차이를 이해하면 각 작업에 적합한 도구를 선택하는 데 도움이 됩니다.

유틸리티	인터페이스	언제 사용하나요	특징
`mitmproxy`	콘솔 TUI	터미널에서 인터랙티브 디버깅	색상을 지원하는 터미널 필요, 강력한 필터
`mitmweb`	웹 브라우저	트래픽의 시각적 분석	편리한 UI, 필터 지원, 내보내기
`mitmdump`	CLI (stdout)	스크립트, CI/CD, 자동화	인터랙티브하지 않음, 파일 또는 파이프에 출력

유용한 실행 플래그

# 트래픽을 파일에 기록
mitmdump -w traffic.dump

# 기록된 트래픽 재생
mitmdump -r traffic.dump

# 필터링: 특정 도메인에 대한 요청만
mitmproxy --filter "~d api.example.com"

# 투명 프록시 모드로 실행
mitmproxy --mode transparent

# 업스트림 프록시로 실행 (프록시 체인)
mitmproxy --mode upstream:http://upstream-proxy:8080

# 특정 포트 지정
mitmweb --listen-port 9090 --web-port 9091

# 스크립트와 함께 실행
mitmproxy -s my_script.py

mitmproxy 필터 문법

mitmproxy는 필요한 요청을 선택하기 위한 강력한 필터 언어를 지원합니다:

# ~d — 도메인 필터
~d api.example.com

# ~u — URL 필터 (정규 표현식)
~u /api/v2/users

# ~m — HTTP 메소드 필터
~m POST

# ~s — 응답만
~s ~c 404

# ~c — 상태 코드 필터
~c 500

# 조합 (AND)
~d api.example.com & ~m POST

# 조합 (OR)
~c 404 | ~c 500

# NOT
!~d static.example.com

Python 스크립트 작성: 트래픽 가로채기 및 수정

스크립트는 mitmproxy의 주요 강점입니다. 이를 통해 요청과 응답을 자동으로 변경하고, 필요한 형식으로 데이터를 기록하고, 서버 오류를 시뮬레이션하는 등 다양한 작업을 수행할 수 있습니다. 스크립트는 Python으로 작성되며 이벤트 기반 모델을 사용합니다.

주요 이벤트 (후크)

후크	언제 호출되는가	객체
`request`	클라이언트로부터 요청을 받음	`flow.request`
`response`	서버로부터 응답을 받음	`flow.response`
`error`	연결 오류 발생	`flow.error`
`tls_start_client`	클라이언트와 TLS 핸드셰이크 시작	`tls_start`

예제 1: 요청을 파일에 기록하기

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

def request(flow: mitmproxy.http.HTTPFlow) -> None:
    """각 요청을 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:
    """오류 코드가 있는 응답을 기록합니다."""
    if flow.response.status_code >= 400:
        print(f"[ERROR] {flow.request.method} {flow.request.pretty_url} "
              f"-> {flow.response.status_code}")

스크립트 실행:

mitmproxy -s logger.py

예제 2: 요청 수정 — 헤더 변경하기

# modify_headers.py
from mitmproxy import http

def request(flow: http.HTTPFlow) -> None:
    """User-Agent를 변경하고 사용자 정의 헤더를 추가합니다."""
    if "api.example.com" in flow.request.pretty_host:
        # 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"
        )
        # 인증 헤더 추가
        flow.request.headers["X-Custom-Token"] = "test-token-12345"
        # 헤더 삭제
        if "X-Debug-Info" in flow.request.headers:
            del flow.request.headers["X-Debug-Info"]

예제 3: 서버 응답 변경하기 (mock)

# mock_response.py
from mitmproxy import http
import json

def request(flow: http.HTTPFlow) -> None:
    """요청을 가로채고 서버에 접근하지 않고 mock 응답을 반환합니다."""
    if flow.request.pretty_url.endswith("/api/v1/user/profile"):
        # mock 응답 생성
        mock_data = {
            "id": 42,
            "name": "Test User",
            "email": "[email protected]",
            "premium": True  # 프리미엄 기능 테스트
        }
        flow.response = http.Response.make(
            200,  # 상태 코드
            json.dumps(mock_data),  # 응답 본문
            {"Content-Type": "application/json"}  # 헤더
        )

def response(flow: http.HTTPFlow) -> None:
    """서버의 실제 응답을 수정합니다."""
    if "/api/v1/products" in flow.request.pretty_url:
        try:
            data = json.loads(flow.response.text)
            # 각 제품에 필드 추가
            for product in data.get("items", []):
                product["debug_info"] = "intercepted"
            flow.response.text = json.dumps(data)
        except (json.JSONDecodeError, KeyError):
            pass

예제 4: 느린 연결 및 오류 시뮬레이션

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

def response(flow: http.HTTPFlow) -> None:
    """Chaos engineering: 테스트를 위한 무작위 지연 및 오류."""
    # 0초에서 2초 사이의 무작위 지연 추가
    if "api.example.com" in flow.request.pretty_host:
        delay = random.uniform(0, 2.0)
        time.sleep(delay)

    # 10% 확률로 503 응답
    if random.random() < 0.1:
        flow.response = http.Response.make(
            503,
            json.dumps({"error": "Service Unavailable"}),
            {"Content-Type": "application/json"}
        )

모바일 애플리케이션 트래픽 가로채기

모바일 애플리케이션의 트래픽 분석은 mitmproxy를 사용할 때 가장 일반적인 작업 중 하나입니다. 이는 모바일 애플리케이션의 API를 리버스 엔지니어링하거나 실제 장치에서 자체 애플리케이션을 테스트할 때 특히 유용합니다.

Android에서 설정하기

1단계. 전화기와 컴퓨터가 동일한 Wi-Fi 네트워크에 있는지 확인하세요.

2단계. 컴퓨터에서 mitmproxy를 실행하세요:

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

3단계. Android: 설정 → Wi-Fi → 네트워크를 길게 누르기 → 네트워크 변경 → 고급 → 프록시 → 수동. 컴퓨터의 IP와 포트 8080을 입력하세요.

4단계. Android에 인증서 설치하기: 장치의 브라우저를 열고 http://mitm.it로 이동하여 Android용 인증서를 다운로드합니다. 그런 다음: 설정 → 보안 → 인증서 설치 → CA 인증서.

Android 7 이상 및 인증서 고정

Android 7.0부터는 애플리케이션이 기본적으로 사용자 CA 인증서를 신뢰하지 않습니다. 이러한 애플리케이션의 트래픽을 가로채려면 루트 권한이 필요하거나 APK의 network_security_config.xml을 수정해야 합니다. SSL 핀닝이 있는 애플리케이션의 경우 Frida 또는 Xposed Framework를 사용하여 인증서 검사를 우회하세요.

iOS에서 설정하기

1단계. Android와 유사하게 프록시 설정: 설정 → Wi-Fi → 네트워크 옆의 (i)를 누르기 → 프록시 설정 → 수동.

2단계. Safari를 열고 http://mitm.it로 이동하여 iOS용 인증서를 다운로드합니다.

3단계. 프로필 설치: 설정 → 다운로드한 프로필 → 설치.

4단계. 인증서 신뢰 설정: 설정 → 일반 → 기기 정보 → 인증서 신뢰 — mitmproxy에 대한 스위치를 켭니다.

Python을 통한 특정 애플리케이션의 트래픽 가로채기

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

# 관심 있는 애플리케이션의 도메인
TARGET_DOMAINS = ["api.myapp.com", "cdn.myapp.com"]

def response(flow: http.HTTPFlow) -> None:
    """모바일 애플리케이션의 트래픽을 분석합니다."""
    host = flow.request.pretty_host

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

    # 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

    # 요청 헤더에서 토큰 찾기
    auth_header = flow.request.headers.get("authorization", "")
    if auth_header:
        print(f"[AUTH] Token found: {auth_header[:50]}...")

프록시 체인: mitmproxy + 업스트림 프록시

강력한 시나리오 중 하나는 mitmproxy를 외부 프록시 서버와 함께 사용하는 것입니다. 이를 통해 트래픽을 동시에 가로채고 분석할 수 있으며 (mitmproxy를 통해) 외부 IP 주소를 통해 전달할 수 있습니다 (업스트림 프록시를 통해). 이 구조는 지리적으로 의존적인 API를 테스트하거나 프록시를 통해 작동해야 하는 애플리케이션을 개발할 때 사용됩니다.

업스트림 프록시 모드

# 모든 트래픽을 업스트림 HTTP 프록시를 통해 전달
mitmproxy --mode upstream:http://proxy-host:port

# 업스트림 SOCKS5 프록시
mitmproxy --mode upstream:socks5://proxy-host:port

# 인증이 필요한 경우
mitmproxy --mode upstream:http://user:password@proxy-host:port

# mitmweb과 함께 업스트림으로 실행
mitmweb --mode upstream:http://proxy-host:port

이 모드에서 mitmproxy는 로컬에서 요청을 수신하고 HTTPS를 복호화하여 분석 및 수정할 수 있는 기회를 제공한 후 외부 프록시를 통해 전달합니다. 이는 특정 지역에서만 접근 가능한 API를 테스트할 때 특히 유용합니다.

이러한 작업에는 주거용 프록시가 적합합니다. 이들은 필요한 국가의 실제 사용자 IP 주소를 가지고 있어 지리적으로 의존적인 API 응답을 올바르게 테스트할 수 있습니다.

스크립트에서 동적 업스트림 프록시 선택하기

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

# 회전할 프록시 목록
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:
    """각 요청에 대해 업스트림 프록시를 회전합니다."""
    global proxy_index

    # API에 대한 요청을 다양한 프록시를 통해 전달
    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}")

투명 프록시 (transparent mode)

투명 모드에서는 애플리케이션이 자신의 트래픽이 가로채지고 있다는 것을 알지 못합니다. 설정에서 프록시를 설정할 필요가 없습니다. 이는 OS 수준에서 iptables/pf 설정이 필요합니다:

# 투명 모드로 실행
mitmproxy --mode transparent --listen-port 8080

# 트래픽 리디렉션을 위한 iptables 설정 (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

mitmproxy의 실용적인 사용 사례

개발자들이 실제 프로젝트에서 mitmproxy를 사용하여 해결하는 구체적인 작업을 살펴보겠습니다.

시나리오 1: 서버를 변경하지 않고 API 테스트하기

가정해 보세요: 프론트엔드가 빈 데이터 배열 또는 401 인증 오류 응답을 처리하는 방법을 확인해야 하지만, 이를 테스트 서버에서 재현하기는 어렵습니다. mitmproxy를 사용하면 응답을 즉시 변경할 수 있습니다:

# test_edge_cases.py
from mitmproxy import http
import json

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

    # 테스트: 빈 상품 목록
    if "/api/products" in url and "test_empty=1" in url:
        flow.response.text = json.dumps({"items": [], "total": 0})

    # 테스트: 만료된 토큰
    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"}
        )

    # 테스트: 요청 한도 초과
    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"}
        )

시나리오 2: 세션 기록 및 재생

실제 서버 없이 테스트 픽스처를 만들거나 기능을 시연하는 데 유용합니다:

# 세션을 파일에 기록
mitmdump -w session.dump --filter "~d api.example.com"

# 기록된 세션 재생 (오프라인)
mitmdump -r session.dump

# 분석을 위한 HAR 형식으로 변환
mitmdump -r session.dump --flow-detail 3 > session.txt

시나리오 3: API 자동 문서화

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

# 엔드포인트에 대한 정보를 축적하기 위한 사전
endpoints = defaultdict(lambda: {"methods": set(), "status_codes": set(),
                                  "request_fields": set(), "response_fields": set()})

def _extract_fields(data, prefix=""):
    """JSON에서 필드를 재귀적으로 추출합니다."""
    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

    # URL 정규화 (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)

    # 요청 필드 추출
    if flow.request.text:
        try:
            req_data = json.loads(flow.request.text)
            ep["request_fields"].update(_extract_fields(req_data))
        except json.JSONDecodeError:
            pass

    # 응답 필드 추출
    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():
    """완료 시 문서화를 출력합니다."""
    print("\n=== API DOCUMENTATION ===\n")
    for endpoint, info in sorted(endpoints.items()):
        print(f"Endpoint: {endpoint}")
        print(f"  Status codes: {sorted(info['status_codes'])}")
        if info["request_fields"]:
            print(f"  Request fields: {sorted(info['request_fields'])}")
        if info["response_fields"]:
            print(f"  Response fields: {sorted(info['response_fields'])}")
        print()

시나리오 4: 지리적으로 의존적인 응답 테스트

지역 콘텐츠가 있는 애플리케이션을 개발할 때 API가 다양한 국가의 요청에 어떻게 응답하는지 확인하는 것이 중요합니다. 이를 위해 mitmproxy는 데이터 센터 프록시와 함께 업스트림 모드로 실행되어야 합니다. 이는 특정 국가에서의 요청을 시뮬레이션하는 빠르고 신뢰할 수 있는 방법입니다.

# geo_test.py
from mitmproxy import http

def response(flow: http.HTTPFlow) -> None:
    """지리적으로 의존적인 헤더와 데이터를 기록합니다."""
    # 서버가 반환하는 콘텐츠 확인
    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}")

    # 응답에서 통화 및 로케일 언급 찾기
    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}")

시나리오 5: CI/CD에서 mitmproxy 사용하기

mitmdump는 CI/CD 파이프라인에서 통합 테스트에 적합합니다. 백그라운드 프로세스로 실행되며 트래픽을 기록하고 테스트와 함께 종료됩니다:

#!/bin/bash
# ci_test.sh

# 백그라운드에서 mitmdump 실행
mitmdump -w test_traffic.dump -s ci_assertions.py &
MITM_PID=$!

# 프록시가 시작될 시간을 줍니다
sleep 1

# 프록시와 함께 테스트 실행
export HTTP_PROXY=http://127.0.0.1:8080
export HTTPS_PROXY=http://127.0.0.1:8080
pytest tests/integration/ -v

# mitmdump 종료
kill $MITM_PID

# 기록된 트래픽 분석
mitmdump -r test_traffic.dump -s analyze_traffic.py

ci_assertions.py 스크립트는 애플리케이션이 불필요한 요청을 하지 않도록 하고, 민감한 데이터를 암호화되지 않은 상태로 전송하지 않으며, API 계약을 준수하는지 확인할 수 있습니다.

시나리오 6: 파서의 트래픽 분석

파서를 개발할 때 mitmproxy는 브라우저가 페이지를 로드할 때 어떤 요청을 하는지 이해하는 데 도움이 됩니다. 여기에는 HTML 소스 코드에서 보이지 않는 API에 대한 XHR/fetch 요청이 포함됩니다. 이를 통해 HTML을 파싱하는 대신 사이트의 API에 직접 접근할 수 있습니다. 이러한 솔루션을 개발할 때는 주거용 프록시를 사용하여 IP를 회전시켜 데이터 수집 시 차단을 피하는 것이 일반적입니다.

결론

mitmproxy는 HTTP/HTTPS 트래픽을 처리하는 개발자의 도구 중 가장 강력한 도구 중 하나입니다. 이는 디버거, 테스트 환경, API 문서화 도구 및 보안 분석 도구의 기능을 통합합니다. 세 가지 인터페이스 — 콘솔, 웹 및 CLI —는 인터랙티브 디버깅에서 CI/CD 자동화에 이르기까지 모든 시나리오를 커버합니다.