Il proxy non supporta il protocollo richiesto: cosa fare

Hai configurato il proxy, avviato lo script e ricevuto un errore come "Protocol not supported" o "Connection refused". Il problema di incompatibilità dei protocolli è più comune di quanto si pensi. Vediamo perché succede e come risolvere il problema senza cambiare provider di proxy.

Quali protocolli utilizzano i proxy

Prima di risolvere il problema, è fondamentale comprendere la differenza tra i protocolli. Ognuno ha il suo campo di applicazione e le sue limitazioni.

Conflitti tipici:

• Selenium e Puppeteer richiedono HTTP/HTTPS, ma si dispone di SOCKS5
• I bot di Telegram funzionano tramite SOCKS5, ma il proxy supporta solo HTTP
• I client Torrent richiedono SOCKS5 con UDP, ma il proxy è SOCKS4
• Le applicazioni di gioco richiedono UDP, ma i proxy HTTP non lo supportano

Diagnostica: identificare il protocollo del proxy

Se il provider non ha specificato esplicitamente il protocollo o si hanno dubbi, è possibile verificarlo autonomamente.

Verifica tramite curl

Testiamo il protocollo HTTP:

# Proxy HTTP
curl -x http://proxy_ip:port http://httpbin.org/ip

# Con autenticazione
curl -x http://user:pass@proxy_ip:port http://httpbin.org/ip

Testiamo SOCKS5:

# Proxy SOCKS5
curl -x socks5://proxy_ip:port http://httpbin.org/ip

# SOCKS5 con DNS tramite proxy (socks5h)
curl -x socks5h://proxy_ip:port http://httpbin.org/ip

Se il comando restituisce l'indirizzo IP del proxy, il protocollo è stato identificato correttamente. Se si verifica un errore come Connection refused o Unsupported proxy, il protocollo non è quello giusto.

Verifica tramite Python

import requests

proxy_ip = "proxy_ip:port"

# Test HTTP
try:
    r = requests.get("http://httpbin.org/ip", 
                     proxies={"http": f"http://{proxy_ip}"}, 
                     timeout=10)
    print(f"HTTP funziona: {r.json()}")
except Exception as e:
    print(f"HTTP non funziona: {e}")

# Test SOCKS5 (richiede pip install requests[socks])
try:
    r = requests.get("http://httpbin.org/ip", 
                     proxies={"http": f"socks5://{proxy_ip}"}, 
                     timeout=10)
    print(f"SOCKS5 funziona: {r.json()}")
except Exception as e:
    print(f"SOCKS5 non funziona: {e}")

Rilevamento automatico

Script per ciclare i protocolli:

import requests

def detect_protocol(proxy_address):
    protocols = ["http", "https", "socks4", "socks5", "socks5h"]
    
    for proto in protocols:
        try:
            proxies = {
                "http": f"{proto}://{proxy_address}",
                "https": f"{proto}://{proxy_address}"
            }
            r = requests.get("http://httpbin.org/ip", 
                           proxies=proxies, timeout=5)
            if r.status_code == 200:
                return proto
        except:
            continue
    return None

result = detect_protocol("proxy_ip:port")
print(f"Protocollo rilevato: {result}")

Conversione da HTTP a SOCKS e viceversa

Se il proxy supporta un protocollo diverso da quello richiesto dal tuo software, utilizza un convertitore locale.

Privoxy: HTTP → SOCKS

Privoxy accetta richieste HTTP e le inoltra tramite un proxy SOCKS.

Installazione:

# Ubuntu/Debian
sudo apt install privoxy

# macOS
brew install privoxy

# Windows — scaricare dal sito ufficiale

Configurazione (file /etc/privoxy/config):

# Ascolta sulla porta locale 8118 (HTTP)
listen-address 127.0.0.1:8118

# Inoltra tramite SOCKS5 esterno
forward-socks5 / socks_proxy_ip:1080 .

# Con autenticazione
forward-socks5 / user:pass@socks_proxy_ip:1080 .

Ora il tuo software si connetterà a 127.0.0.1:8118 in HTTP, e il traffico verrà instradato tramite SOCKS5.

Gost: convertitore universale

Gost è uno strumento potente per qualsiasi tipo di conversione di protocollo.

# Proxy HTTP in ingresso → SOCKS5 in uscita
gost -L http://:8080 -F socks5://socks_proxy_ip:1080

# SOCKS5 in ingresso → HTTP in uscita
gost -L socks5://:1080 -F http://http_proxy_ip:8080

# Con autenticazione su entrambi i lati
gost -L http://local_user:local_pass@:8080 \
     -F socks5://remote_user:remote_pass@proxy_ip:1080

Convertitore in Python

Convertitore minimalista per compiti semplici:

# pip install pproxy
# HTTP in ingresso, SOCKS5 in uscita
pproxy -l http://:8080 -r socks5://proxy_ip:1080

# SOCKS5 in ingresso, HTTP in uscita  
pproxy -l socks5://:1080 -r http://proxy_ip:8080

Configurazione di tunnel locali

A volte la conversione non è sufficiente: è necessario un tunnel completo.

Tunnel SSH tramite proxy HTTP

Se si dispone di un server SSH e di un proxy HTTP, è possibile creare un SOCKS5:

# Crea un SOCKS5 su localhost:1080 tramite proxy HTTP
ssh -D 1080 -o ProxyCommand="nc -X connect -x http_proxy:8080 %h %p" user@ssh_server

Stunnel per HTTPS

Se è richiesto un proxy HTTPS ma si dispone solo di HTTP:

# stunnel.conf
[https-proxy]
client = yes
accept = 127.0.0.1:8443
connect = http_proxy_ip:8080
protocol = connect
protocolHost = target_host:443

Configurare il software per il protocollo disponibile

A volte è più semplice configurare il software per il protocollo disponibile piuttosto che convertirlo.

Selenium con diversi protocolli

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Proxy HTTP (metodo standard)
options = Options()
options.add_argument('--proxy-server=http://proxy_ip:8080')

# Proxy SOCKS5
options.add_argument('--proxy-server=socks5://proxy_ip:1080')

# Per Firefox con SOCKS5
from selenium.webdriver.firefox.options import Options as FirefoxOptions
profile = webdriver.FirefoxProfile()
profile.set_preference("network.proxy.type", 1)
profile.set_preference("network.proxy.socks", "proxy_ip")
profile.set_preference("network.proxy.socks_port", 1080)
profile.set_preference("network.proxy.socks_version", 5)

aiohttp con SOCKS

# pip install aiohttp-socks
import aiohttp
from aiohttp_socks import ProxyConnector

async def fetch_with_socks():
    connector = ProxyConnector.from_url('socks5://proxy_ip:1080')
    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get('http://httpbin.org/ip') as response:
            return await response.json()

Bot Telegram tramite HTTP

Se la libreria di Telegram richiede SOCKS5 ma si dispone di HTTP:

# python-telegram-bot con proxy HTTP
from telegram.ext import ApplicationBuilder

application = (
    ApplicationBuilder()
    .token("YOUR_TOKEN")
    .proxy_url("http://proxy_ip:8080")  # Funziona con HTTP
    .build()
)

Suggerimento: Molte librerie moderne supportano entrambi i protocolli. Controlla la documentazione: potrebbe essere sufficiente cambiare lo schema URL da socks5:// a http://.

Come scegliere un proxy con il protocollo corretto

Per evitare problemi di protocollo, definisci i requisiti in anticipo.

Matrice di compatibilità

Cosa considerare nella scelta del provider

• Elenco dei protocolli supportati — deve essere indicato esplicitamente
• Possibilità di commutazione — alcuni provider consentono l'accesso allo stesso IP tramite porte/protocolli diversi
• Supporto UDP per SOCKS5 — non tutti i proxy SOCKS5 supportano UDP
• Documentazione di configurazione — esempi per diversi linguaggi e strumenti

I proxy residenziali di solito supportano HTTP/HTTPS e SOCKS5 contemporaneamente, il che elimina la maggior parte dei problemi di compatibilità. I proxy datacenter sono più spesso limitati a HTTP/HTTPS.

Checklist prima dell'acquisto

1. Determina quale protocollo è richiesto dal tuo software
2. Verifica se è necessario il supporto UDP (giochi, torrent, VoIP)
3. Chiedi al provider il supporto per il protocollo desiderato
4. Richiedi un accesso di prova per verificare la compatibilità
5. Prepara un piano B: un convertitore locale

Conclusione

L'incompatibilità dei protocolli è un problema risolvibile. Nella maggior parte dei casi, è sufficiente un convertitore locale come Privoxy o Gost. Per progetti a lungo termine, è più vantaggioso scegliere subito un proxy che supporti il protocollo necessario.

Per attività che richiedono flessibilità nella scelta del protocollo, sono adatti i proxy residenziali con accesso multiprotocollo — maggiori dettagli su proxycove.com.