प्रॉक्सी का उपयोग करते समय SSL/TLS समस्याओं का समाधान: संपूर्ण मार्गदर्शिका

SSL/TLS त्रुटियाँ प्रॉक्सी-सर्वर के माध्यम से काम करते समय सबसे आम समस्याओं में से एक हैं। गलत कॉन्फ़िगरेशन से कनेक्शन विफलता, डेटा रिसाव और संरक्षित संसाधनों को पार्स करने में असमर्थता होती है। इस मार्गदर्शिका में हम त्रुटियों के कारणों और उनके समाधान के तरीकों को विशिष्ट कोड उदाहरणों के साथ समझेंगे।

प्रॉक्सी के माध्यम से SSL/TLS कैसे काम करता है

समस्याओं को हल करने से पहले, प्रॉक्सी के माध्यम से संरक्षित कनेक्शन की कार्यप्रणाली को समझना महत्वपूर्ण है। HTTPS-ट्रैफिक को प्रॉक्सी करने के लिए दो मौलिक रूप से अलग दृष्टिकोण हैं, और प्रत्येक के अपने विशेषताएँ, लाभ और संभावित विफलता बिंदु हैं।

पारदर्शी सुरंग (CONNECT)

CONNECT विधि का उपयोग करते समय, प्रॉक्सी-सर्वर क्लाइंट और लक्ष्य सर्वर के बीच एक TCP-सुरंग बनाता है। प्रॉक्सी ट्रैफिक की सामग्री नहीं देख सकता — यह बस दोनों तरफ से एन्क्रिप्ट किए गए बाइट्स को प्रेषित करता है। यह प्रॉक्सी के माध्यम से HTTPS के साथ काम करने के लिए सबसे सुरक्षित और सामान्य विधि है।

कनेक्शन स्थापना की प्रक्रिया इस प्रकार दिखती है: क्लाइंट प्रॉक्सी को लक्ष्य होस्ट और पोर्ट के साथ CONNECT अनुरोध भेजता है। प्रॉक्सी लक्ष्य सर्वर के साथ TCP-कनेक्शन स्थापित करता है और क्लाइंट को 200 Connection Established प्रतिक्रिया देता है। इसके बाद क्लाइंट स्थापित सुरंग के माध्यम से लक्ष्य सर्वर के साथ सीधे TLS-हैंडशेक करता है।

# CONNECT-सुरंग की योजना
क्लाइंट → प्रॉक्सी: CONNECT example.com:443 HTTP/1.1
प्रॉक्सी → सर्वर: [पोर्ट 443 पर TCP-कनेक्शन]
प्रॉक्सी → क्लाइंट: HTTP/1.1 200 Connection Established
क्लाइंट ↔ सर्वर: [सुरंग के माध्यम से TLS-हैंडशेक]
क्लाइंट ↔ सर्वर: [एन्क्रिप्ट की गई ट्रैफिक]

MITM-प्रॉक्सिंग (अवरोधन)

कुछ प्रॉक्सी (विशेषकर कॉर्पोरेट) Man-in-the-Middle तकनीक का उपयोग करते हैं: वे अपने पक्ष पर TLS-कनेक्शन को समाप्त करते हैं, ट्रैफिक को डिक्रिप्ट करते हैं, और फिर लक्ष्य सर्वर के साथ एक नया TLS-कनेक्शन स्थापित करते हैं। इसके लिए प्रॉक्सी प्रत्येक डोमेन के लिए एक अपनी प्रमाणपत्र उत्पन्न करता है, जिसे प्रॉक्सी की रूट प्रमाणपत्र द्वारा हस्ताक्षरित किया जाता है।

यह दृष्टिकोण HTTPS-ट्रैफिक को निरीक्षण और फ़िल्टर करने की अनुमति देता है, लेकिन क्लाइंट के विश्वसनीय स्टोर में प्रॉक्सी की रूट प्रमाणपत्र को स्थापित करने की आवश्यकता होती है। यह वह जगह है जहाँ कॉर्पोरेट नेटवर्क के माध्यम से काम करते समय SSL/TLS के साथ अधिकांश समस्याएँ उत्पन्न होती हैं।

विशिष्ट त्रुटियाँ और उनके कारण

प्रॉक्सी के माध्यम से काम करते समय सबसे आम SSL/TLS त्रुटियों पर विचार करें। प्रत्येक त्रुटि के कारणों को समझना समस्या को जल्दी हल करने की कुंजी है।

SSL: CERTIFICATE_VERIFY_FAILED

यह त्रुटि इंगित करती है कि क्लाइंट सर्वर की प्रमाणपत्र की प्रामाणिकता को सत्यापित नहीं कर सकता। कई कारण हो सकते हैं: प्रॉक्सी MITM-निरीक्षण का उपयोग करता है लेकिन रूट प्रमाणपत्र स्थापित नहीं है, लक्ष्य सर्वर की प्रमाणपत्र समाप्त हो गई है या स्व-हस्ताक्षरित है, या प्रमाणपत्र श्रृंखला में मध्यवर्ती प्रमाणपत्र अनुपस्थित है।

# Python - विशिष्ट त्रुटि संदेश
ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] 
certificate verify failed: unable to get local issuer certificate

# Node.js
Error: unable to verify the first certificate

# cURL
curl: (60) SSL certificate problem: unable to get local issuer certificate

SSL: WRONG_VERSION_NUMBER

त्रुटि तब होती है जब क्लाइंट TLS-कनेक्शन स्थापित करने का प्रयास करता है, लेकिन अप्रत्याशित प्रारूप में प्रतिक्रिया प्राप्त करता है। अक्सर यह तब होता है जब प्रॉक्सी CONNECT-विधि का समर्थन नहीं करता और HTTPS-अनुरोध को सामान्य HTTP के रूप में संभालने का प्रयास करता है। कारण गलत पोर्ट या प्रोटोकॉल भी हो सकता है।

TLSV1_ALERT_PROTOCOL_VERSION

सर्वर असंगत TLS-प्रोटोकॉल संस्करण के कारण कनेक्शन को अस्वीकार करता है। आधुनिक सर्वर सुरक्षा कारणों से TLS 1.0 और TLS 1.1 के पुराने संस्करणों को अक्षम करते हैं। यदि प्रॉक्सी या क्लाइंट पुराने संस्करणों का उपयोग करने के लिए कॉन्फ़िगर किए गए हैं, तो कनेक्शन अस्वीकार कर दिया जाएगा।

SSLV3_ALERT_HANDSHAKE_FAILURE

क्लाइंट और सर्वर एन्क्रिप्शन पैरामीटर पर सहमत नहीं हो सके। यह cipher suites की कमी, SNI (Server Name Indication) समस्याओं, या क्रिप्टोग्राफिक लाइब्रेरी की असंगतता के कारण हो सकता है।

प्रमाणपत्र समस्याएँ

प्रमाणपत्र प्रॉक्सी के माध्यम से काम करते समय समस्याओं का सबसे आम स्रोत हैं। मुख्य परिदृश्यों और उनके समाधान पर विचार करें।

प्रॉक्सी की रूट प्रमाणपत्र स्थापित करना

यदि प्रॉक्सी MITM-निरीक्षण का उपयोग करता है, तो इसकी रूट प्रमाणपत्र को विश्वसनीय स्टोर में जोड़ना आवश्यक है। प्रक्रिया ऑपरेटिंग सिस्टम और उपयोग की जाने वाली प्रोग्रामिंग भाषा पर निर्भर करती है।

# Linux: सिस्टम स्टोर में प्रमाणपत्र जोड़ना
sudo cp proxy-ca.crt /usr/local/share/ca-certificates/
sudo update-ca-certificates

# macOS: Keychain में जोड़ना
sudo security add-trusted-cert -d -r trustRoot \
    -k /Library/Keychains/System.keychain proxy-ca.crt

# Windows PowerShell (प्रशासक से)
Import-Certificate -FilePath "proxy-ca.crt" `
    -CertStoreLocation Cert:\LocalMachine\Root

कोड में प्रमाणपत्र निर्दिष्ट करना

कभी-कभी कोड में सीधे प्रमाणपत्र पथ निर्दिष्ट करना अधिक सुविधाजनक होता है, विशेषकर कंटेनर या रूट-एक्सेस के बिना सर्वर पर काम करते समय। यह सिस्टम सेटिंग्स को संशोधित करने से बचने की अनुमति देता है।

# Python: कस्टम CA-bundle निर्दिष्ट करना
import requests

# विधि 1: प्रमाणपत्र फ़ाइल का पथ निर्दिष्ट करें
response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy:8080'},
    verify='/path/to/proxy-ca.crt'
)

# विधि 2: सिस्टम प्रमाणपत्रों के साथ संयोजित करें
import certifi
import ssl

# संयुक्त प्रमाणपत्र फ़ाइल बनाएँ
with open('combined-ca.crt', 'w') as combined:
    with open(certifi.where()) as system_certs:
        combined.write(system_certs.read())
    with open('proxy-ca.crt') as proxy_cert:
        combined.write(proxy_cert.read())

response = requests.get(url, verify='combined-ca.crt')

प्रमाणपत्र सत्यापन अक्षम करना

कुछ मामलों में (केवल परीक्षण और डिबगिंग के लिए!) प्रमाणपत्र सत्यापन को अक्षम करने की आवश्यकता हो सकती है। यह असुरक्षित है और उत्पादन में उपयोग नहीं किया जाना चाहिए, क्योंकि यह कनेक्शन को MITM-हमलों के लिए कमजोर बनाता है।

⚠️ चेतावनी: प्रमाणपत्र सत्यापन को अक्षम करने से कनेक्शन अवरोधन के लिए कमजोर हो जाता है। केवल अलग-थलग वातावरण में डिबगिंग के लिए उपयोग करें, कभी भी उत्पादन में नहीं!

# Python - केवल डिबगिंग के लिए!
import requests
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy:8080'},
    verify=False  # असुरक्षित!
)

CONNECT-सुरंगों का सेटअप

CONNECT-सुरंग का सही सेटअप प्रॉक्सी के माध्यम से HTTPS के स्थिर काम की कुंजी है। विभिन्न उपयोग परिदृश्यों के लिए सेटअप की विशेषताओं पर विचार करें।

CONNECT समर्थन की जाँच

सभी प्रॉक्सी CONNECT विधि का समर्थन नहीं करते। HTTP-प्रॉक्सी केवल HTTP-ट्रैफिक को प्रॉक्सी करने के लिए कॉन्फ़िगर किए जा सकते हैं। उपयोग से पहले सुनिश्चित करें कि प्रॉक्सी HTTPS-सुरंग का समर्थन करता है।

# netcat/telnet के माध्यम से CONNECT समर्थन की जाँच
echo -e "CONNECT example.com:443 HTTP/1.1\r\nHost: example.com:443\r\n\r\n" | \
    nc proxy.example.com 8080

# सफलता पर अपेक्षित प्रतिक्रिया:
# HTTP/1.1 200 Connection Established

# त्रुटि पर संभावित प्रतिक्रियाएँ:
# HTTP/1.1 403 Forbidden - CONNECT निषिद्ध है
# HTTP/1.1 405 Method Not Allowed - विधि समर्थित नहीं है

CONNECT-अनुरोधों में प्रमाणीकरण

प्रमाणीकरण के साथ प्रॉक्सी का उपयोग करते समय, CONNECT-अनुरोध में सही तरीके से क्रेडेंशियल पास करना महत्वपूर्ण है। Proxy-Authorization हेडर CONNECT-अनुरोध में मौजूद होना चाहिए।

# Python: URL के माध्यम से प्रमाणीकरण
import requests

proxy_url = 'http://username:password@proxy.example.com:8080'
response = requests.get(
    'https://target.com',
    proxies={'https': proxy_url}
)

# Python: हेडर के माध्यम से प्रमाणीकरण (जटिल मामलों के लिए)
import base64

credentials = base64.b64encode(b'username:password').decode('ascii')
session = requests.Session()
session.headers['Proxy-Authorization'] = f'Basic {credentials}'
session.proxies = {'https': 'http://proxy.example.com:8080'}

response = session.get('https://target.com')

SOCKS5-प्रॉक्सी के साथ काम करना

SOCKS5-प्रॉक्सी निम्न स्तर पर काम करते हैं और HTTPS के विशेष उपचार की आवश्यकता नहीं है। वे बस TCP-कनेक्शन को सुरंग बनाते हैं, जो उन्हें किसी भी प्रोटोकॉल के साथ काम करने के लिए आदर्श बनाता है।

# PySocks के साथ Python
import requests

proxies = {
    'http': 'socks5h://user:pass@proxy:1080',
    'https': 'socks5h://user:pass@proxy:1080'
}

# socks5h - प्रॉक्सी के माध्यम से DNS समाधान
# socks5 - स्थानीय DNS समाधान

response = requests.get('https://example.com', proxies=proxies)

विभिन्न प्रोग्रामिंग भाषाओं के लिए समाधान

प्रत्येक भाषा और लाइब्रेरी के प्रॉक्सी के माध्यम से SSL/TLS के साथ काम करने की अपनी विशेषताएँ हैं। सबसे आम विकल्पों पर पूर्ण कोड उदाहरणों के साथ विचार करें।

Python (requests + urllib3)

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.ssl_ import create_urllib3_context
import ssl

class TLSAdapter(HTTPAdapter):
    """अनुकूलनीय TLS पैरामीटर के साथ अडैप्टर"""
    
    def __init__(self, ssl_context=None, **kwargs):
        self.ssl_context = ssl_context
        super().__init__(**kwargs)
    
    def init_poolmanager(self, *args, **kwargs):
        if self.ssl_context:
            kwargs['ssl_context'] = self.ssl_context
        return super().init_poolmanager(*args, **kwargs)

# आधुनिक सेटिंग्स के साथ संदर्भ बनाएँ
ctx = create_urllib3_context()
ctx.minimum_version = ssl.TLSVersion.TLSv1_2
ctx.set_ciphers('ECDHE+AESGCM:DHE+AESGCM:ECDHE+CHACHA20')

# अतिरिक्त प्रमाणपत्र लोड करें
ctx.load_verify_locations('proxy-ca.crt')

session = requests.Session()
session.mount('https://', TLSAdapter(ssl_context=ctx))
session.proxies = {
    'http': 'http://proxy:8080',
    'https': 'http://proxy:8080'
}

response = session.get('https://example.com')
print(response.status_code)

Node.js (axios + https-proxy-agent)

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');
const fs = require('fs');
const https = require('https');

// अतिरिक्त CA-प्रमाणपत्र लोड करें
const customCA = fs.readFileSync('proxy-ca.crt');

const agent = new HttpsProxyAgent({
    host: 'proxy.example.com',
    port: 8080,
    auth: 'username:password',
    ca: customCA,
    rejectUnauthorized: true  // उत्पादन में अक्षम न करें!
});

const client = axios.create({
    httpsAgent: agent,
    proxy: false  // महत्वपूर्ण: axios की अंतर्निहित प्रॉक्सी अक्षम करें
});

async function fetchData() {
    try {
        const response = await client.get('https://example.com');
        console.log(response.data);
    } catch (error) {
        if (error.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE') {
            console.error('प्रमाणपत्र समस्या:', error.message);
        }
        throw error;
    }
}

fetchData();

Go (net/http)

package main

import (
    "crypto/tls"
    "crypto/x509"
    "io/ioutil"
    "net/http"
    "net/url"
    "log"
)

func main() {
    // अतिरिक्त प्रमाणपत्र लोड करें
    caCert, err := ioutil.ReadFile("proxy-ca.crt")
    if err != nil {
        log.Fatal(err)
    }
    
    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCert)
    
    // TLS कॉन्फ़िगरेशन
    tlsConfig := &tls.Config{
        RootCAs:    caCertPool,
        MinVersion: tls.VersionTLS12,
    }
    
    // प्रॉक्सी कॉन्फ़िगरेशन
    proxyURL, _ := url.Parse("http://user:pass@proxy:8080")
    
    transport := &http.Transport{
        Proxy:           http.ProxyURL(proxyURL),
        TLSClientConfig: tlsConfig,
    }
    
    client := &http.Client{Transport: transport}
    
    resp, err := client.Get("https://example.com")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    
    log.Printf("स्थिति: %s", resp.Status)
}

cURL (कमांड लाइन)

# प्रॉक्सी के माध्यम से बुनियादी अनुरोध
curl -x http://proxy:8080 https://example.com

# प्रमाणीकरण के साथ
curl -x http://proxy:8080 -U username:password https://example.com

# CA-प्रमाणपत्र निर्दिष्ट करके
curl -x http://proxy:8080 --cacert proxy-ca.crt https://example.com

# TLS 1.2+ का अनिवार्य उपयोग
curl -x http://proxy:8080 --tlsv1.2 https://example.com

# TLS-हैंडशेक डिबगिंग
curl -x http://proxy:8080 -v --trace-ascii - https://example.com 2>&1 | \
    grep -E "(SSL|TLS|certificate)"

MITM-निरीक्षण का पता लगाना और बायपास करना

कुछ नेटवर्क (कॉर्पोरेट, सार्वजनिक Wi-Fi) HTTPS-ट्रैफिक के पारदर्शी MITM-निरीक्षण का उपयोग करते हैं। यह certificate pinning के साथ समस्याएँ पैदा कर सकता है और निर्दिष्ट प्रमाणपत्रों की अपेक्षा करने वाले अनुप्रयोगों के काम को बाधित कर सकता है।

MITM-प्रॉक्सी का पता लगाना

import ssl
import socket

def check_certificate_issuer(hostname, port=443):
    """वेबसाइट की प्रमाणपत्र जारीकर्ता की जाँच करता है"""
    context = ssl.create_default_context()
    
    with socket.create_connection((hostname, port)) as sock:
        with context.wrap_socket(sock, server_hostname=hostname) as ssock:
            cert = ssock.getpeercert()
            
            issuer = dict(x[0] for x in cert['issuer'])
            subject = dict(x[0] for x in cert['subject'])
            
            print(f"विषय: {subject.get('commonName')}")
            print(f"जारीकर्ता: {issuer.get('commonName')}")
            print(f"संगठन: {issuer.get('organizationName')}")
            
            # ज्ञात कॉर्पोरेट MITM-प्रॉक्सी
            mitm_indicators = [
                'Zscaler', 'BlueCoat', 'Symantec', 'Fortinet',
                'Palo Alto', 'McAfee', 'Cisco', 'Corporate'
            ]
            
            issuer_str = str(issuer)
            for indicator in mitm_indicators:
                if indicator.lower() in issuer_str.lower():
                    print(f"⚠️ MITM-प्रॉक्सी का पता चला: {indicator}")
                    return True
            
            return False

# जाँच
check_certificate_issuer('google.com')

MITM की स्थितियों में काम करना

यदि MITM-प्रॉक्सी का पता चलता है, तो काम करने की कई रणनीतियाँ हैं। प्रॉक्सी की रूट प्रमाणपत्र स्थापित कर सकते हैं (यदि यह विश्वसनीय कॉर्पोरेट नेटवर्क है), वैकल्पिक पोर्ट या प्रोटोकॉल का उपयोग कर सकते हैं, या निरीक्षण को बायपास करने के लिए VPN लागू कर सकते हैं।

# MITM-प्रॉक्सी की प्रमाणपत्र प्राप्त करना स्थापन के लिए
openssl s_client -connect example.com:443 -proxy proxy:8080 \
    -showcerts 2>/dev/null | \
    openssl x509 -outform PEM > mitm-cert.pem

# प्रमाणपत्र की जानकारी देखना
openssl x509 -in mitm-cert.pem -text -noout | head -20

निदान उपकरण

सही निदान समस्या का आधा समाधान है। SSL/TLS-कनेक्शन को प्रॉक्सी के माध्यम से डिबग करने के लिए उपकरणों और विधियों पर विचार करें।

निदान के लिए OpenSSL

# प्रॉक्सी के माध्यम से कनेक्शन की जाँच
openssl s_client -connect example.com:443 \
    -proxy proxy.example.com:8080 \
    -servername example.com

# प्रमाणपत्र श्रृंखला की जाँच
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -showcerts 2>/dev/null | \
    grep -E "(Certificate chain|s:|i:)"

# विशिष्ट TLS संस्करण का परीक्षण
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -tls1_2

# समर्थित cipher suites की जाँच
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -cipher 'ECDHE-RSA-AES256-GCM-SHA384'

निदान के लिए Python-स्क्रिप्ट

import ssl
import socket
import requests
from urllib.parse import urlparse

def diagnose_ssl_proxy(target_url, proxy_url):
    """प्रॉक्सी के माध्यम से SSL का व्यापक निदान"""
    
    print(f"🔍 निदान: {target_url}")
    print(f"📡 प्रॉक्सी: {proxy_url}\n")
    
    # 1. प्रॉक्सी की उपलब्धता की जाँच
    proxy = urlparse(proxy_url)
    try:
        sock = socket.create_connection(
            (proxy.hostname, proxy.port), 
            timeout=10
        )
        sock.close()
        print("✅ प्रॉक्सी उपलब्ध है")
    except Exception as e:
        print(f"❌ प्रॉक्सी उपलब्ध नहीं: {e}")
        return
    
    # 2. CONNECT-विधि की जाँच
    try:
        response = requests.get(
            target_url,
            proxies={'https': proxy_url},
            timeout=15
        )
        print(f"✅ HTTPS-कनेक्शन सफल: {response.status_code}")
    except requests.exceptions.SSLError as e:
        print(f"❌ SSL-त्रुटि: {e}")
        
        # निदान के लिए प्रमाणपत्र सत्यापन के बिना प्रयास
        try:
            response = requests.get(
                target_url,
                proxies={'https': proxy_url},
                verify=False,
                timeout=15
            )
            print("⚠️ प्रमाणपत्र सत्यापन के बिना कनेक्शन काम करता है")
            print("   संभवतः प्रॉक्सी CA-प्रमाणपत्र के साथ समस्या")
        except Exception as e2:
            print(f"❌ सत्यापन के बिना भी काम नहीं करता: {e2}")
    
    except Exception as e:
        print(f"❌ कनेक्शन त्रुटि: {e}")
    
    # 3. SSL जानकारी
    print(f"\n📋 OpenSSL संस्करण: {ssl.OPENSSL_VERSION}")
    print(f"📋 समर्थित प्रोटोकॉल: {ssl.get_default_verify_paths()}")

# उपयोग
diagnose_ssl_proxy(
    'https://httpbin.org/ip',
    'http://proxy:8080'
)

गहन विश्लेषण के लिए Wireshark

जटिल मामलों के लिए TLS-ट्रैफिक पर फ़िल्टर के साथ Wireshark का उपयोग करें। यह हैंडशेक के विवरण देखने और विफलता के सटीक बिंदु को निर्धारित करने की अनुमति देता है।

# TLS-विश्लेषण के लिए Wireshark फ़िल्टर
tls.handshake.type == 1          # Client Hello
tls.handshake.type == 2          # Server Hello
tls.handshake.type == 11         # Certificate
tls.alert_message                 # TLS-अलर्ट (त्रुटियाँ)

# tcpdump के साथ ट्रैफिक कैप्चर करना
tcpdump -i eth0 -w ssl_debug.pcap \
    'port 443 or port 8080' -c 1000

सुरक्षित कार्य के सर्वोत्तम अभ्यास

सर्वोत्तम अभ्यासों का पालन करने से SSL/TLS की अधिकांश समस्याओं से बचा जा सकता है और प्रॉक्सी के माध्यम से काम करते समय आपके डेटा की सुरक्षा सुनिश्चित होगी।

TLS कॉन्फ़िगरेशन

• न्यूनतम TLS 1.2 का उपयोग करें, अधिमानतः TLS 1.3
• आधुनिक cipher suites (ECDHE, AES-GCM, ChaCha20) कॉन्फ़िगर करें
• प्रमाणपत्र सत्यापन सक्षम करें (उत्पादन में कभी अक्षम न करें)
• नियमित रूप से CA-bundle और क्रिप्टोग्राफिक लाइब्रेरी अपडेट करें

प्रॉक्सी के साथ काम करना

• HTTPS-ट्रैफिक के लिए CONNECT समर्थन वाले प्रॉक्सी को प्राथमिकता दें
• सार्वभौमिक सुरंग के लिए SOCKS5 का उपयोग करें
• आवासीय प्रॉक्सी के साथ काम करते समय प्रदाता नेटवर्क की संभावित विशेषताओं को ध्यान में रखें
• प्रॉक्सी क्रेडेंशियल को कोड में नहीं, पर्यावरण चर में संग्रहीत करें

त्रुटि हैंडलिंग

import requests
from requests.exceptions import SSLError, ProxyError, ConnectionError
import time

def robust_request(url, proxy, max_retries=3):
    """त्रुटियों के प्रति प्रतिरोधी प्रॉक्सी अनुरोध"""
    
    for attempt in range(max_retries):
        try:
            response = requests.get(
                url,
                proxies={'https': proxy},
                timeout=30
            )
            return response
            
        except SSLError as e:
            print(f"SSL-त्रुटि (प्रयास {attempt + 1}): {e}")
            # SSL-त्रुटियाँ आमतौर पर पुनः प्रयास से ठीक नहीं होती
            if 'CERTIFICATE_VERIFY_FAILED' in str(e):
                raise  # कॉन्फ़िगरेशन सुधार की आवश्यकता है
                
        except ProxyError as e:
            print(f"प्रॉक्सी त्रुटि (प्रयास {attempt + 1}): {e}")
            time.sleep(2 ** attempt)  # घातीय विलंब
            
        except ConnectionError as e:
            print(f"कनेक्शन त्रुटि (प्रयास {attempt + 1}): {e}")
            time.sleep(2 ** attempt)
    
    raise Exception(f"{max_retries} प्रयासों के बाद अनुरोध निष्पादित नहीं कर सके")

समस्या समाधान चेकलिस्ट

SSL/TLS त्रुटियों के मामले में इस निदान क्रम का पालन करें:

1. प्रॉक्सी-सर्वर की उपलब्धता की जाँच करें (ping, telnet)
2. CONNECT विधि के समर्थन की पुष्टि करें
3. प्रमाणीकरण डेटा की सही जाँच करें
4. openssl s_client के माध्यम से प्रमाणपत्र का अध्ययन करें
5. MITM-निरीक्षण की उपस्थिति की जाँच करें
6. आवश्यक CA-प्रमाणपत्र स्थापित करें
7. TLS संस्करण और cipher suites अपडेट करें

निष्कर्ष

प्रॉक्सी के माध्यम से काम करते समय SSL/TLS समस्याएँ निदान के लिए एक व्यवस्थित दृष्टिकोण के साथ समाधान योग्य हैं। मुख्य बातें: CONNECT-सुरंग और MITM-प्रॉक्सिंग के बीच अंतर को समझना, प्रमाणपत्रों का सही सेटअप और आधुनिक TLS-प्रोटोकॉल संस्करण का उपयोग। अधिकांश त्रुटियाँ आवश्यक CA-प्रमाणपत्रों की कमी या क्रिप्टोग्राफिक पैरामीटर की असंगतता से संबंधित हैं।

पार्सिंग और स्वचालन कार्यों के लिए जिन्हें स्थिर HTTPS कार्य की आवश्यकता है, CONNECT-विधि के पूर्ण समर्थन वाली गुणवत्ता वाली प्रॉक्सी का उपयोग करने की अनुशंसा की जाती है — विकल्पों के बारे में अधिक जानकारी proxycove.com पर उपलब्ध है।