mitmproxy: डेवलपर्स के लिए HTTPS ट्रैफ़िक को इंटरसेप्ट करना

```html

क्या आप मोबाइल एप्लिकेशन को डिबग कर रहे हैं और नहीं समझ पा रहे हैं कि यह सर्वर पर कौन से अनुरोध भेजता है? क्या आपको विभिन्न परिस्थितियों में API के व्यवहार का परीक्षण करने की आवश्यकता है या उत्तर को इंटरसेप्ट करके डेटा को तुरंत बदलने की आवश्यकता है? mitmproxy इन सभी कार्यों को हल करता है - यह एक मुफ्त ओपन-सोर्स उपकरण है जो क्लाइंट और सर्वर के बीच HTTP और HTTPS ट्रैफ़िक को पूरी तरह से नियंत्रित करने की अनुमति देता है।

mitmproxy क्या है और यह डेवलपर के लिए क्यों आवश्यक है

mitmproxy एक इंटरएक्टिव MITM प्रॉक्सी (Man-In-The-Middle Proxy) है, जो Python में लिखा गया है और ओपन-सोर्स है। यह आपके एप्लिकेशन और सर्वर के बीच एक मध्यस्थ के रूप में कार्य करता है: सभी अनुरोधों और उत्तरों को इंटरसेप्ट करता है, उन्हें देखने, संशोधित करने, पुनः उत्पन्न करने और सहेजने की अनुमति देता है।

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 द्वारा फ़िल्टर (regex)
~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 की मदद से वास्तविक परियोजनाओं में हल करते हैं।

परिदृश्य 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

परिदृश्य 6: पार्सर के ट्रैफ़िक का विश्लेषण

पार्सर विकसित करते समय, mitmproxy यह समझने में मदद करता है कि ब्राउज़र पृष्ठ लोड करते समय कौन से अनुरोध करता है - जिसमें XHR/fetch अनुरोध API के लिए शामिल हैं, जो HTML के स्रोत कोड में दिखाई नहीं देते हैं। यह सीधे साइट के API को कॉल करने की अनुमति देता है, HTML को पार्स करने के बजाय। ऐसे समाधानों के विकास में अक्सर रहवासी प्रॉक्सी का उपयोग IP रोटेशन के लिए किया जाता है, ताकि डेटा संग्रह के दौरान ब्लॉक से बचा जा सके।

निष्कर्ष

mitmproxy HTTP/HTTPS ट्रैफ़िक के साथ काम करने के लिए डेवलपर के उपकरणों में से एक सबसे शक्तिशाली है। यह डिबगर, परीक्षण वातावरण, API दस्तावेज़ीकरण और सुरक्षा विश्लेषण उपकरण के कार्यों को संयोजित करता है। तीन इंटरफेस - कंसोल, वेब और CLI - सभी परिदृश्यों को कवर करते हैं: इंटरएक्टिव डिबगिंग से लेकर CI/CD में स्वचालन तक।