---
title: "VLESS"
description: "I trasporti, i flussi, la cifratura, le opzioni TLS, i link e le funzioni di VLESS supportati da Potatso."
---

> Documentation Index
> Fetch the complete documentation index at: https://potatso.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# VLESS

Un server VLESS è descritto da un **ID utente** (un UUID), dalla sua **sicurezza** (nessuna, TLS o REALITY) e da un **trasporto** che porta la connessione, come WebSocket o gRPC. Può usare anche il **flusso Vision**, che nasconde lo schema "TLS dentro TLS" del traffico HTTPS passato da un proxy, e **VLESS Encryption**, il livello di cifratura post-quantistico di Xray. Potatso si connette a un server quando supporta tutte queste impostazioni. Usa le tabelle qui sotto per controllare le impostazioni del tuo server, come le indica il tuo provider o come compaiono nel suo link `vless://`.

Puoi aggiungere un server VLESS a mano, con un [link `vless://`](#links), oppure importando:

- una sottoscrizione Clash o Mihomo,
- una configurazione Xray o V2Ray.

Potatso non importa ancora server VLESS da una configurazione sing-box. Usa invece il link `vless://` del server.

Ogni impostazione supportata qui sotto è testata con server [Xray](https://github.com/XTLS/Xray-core) e [sing-box](https://sing-box.sagernet.org/) reali.

## ID utente {#user-id}

L'ID utente è normalmente un UUID, come `3971e1b2-18a3-4f83-8fa6-bf9b142ee258`. I server Xray accettano come ID anche qualsiasi altro testo fino a 30 caratteri, e lo trasformano in un UUID nello stesso modo in cui lo fa ogni client. Lo fa anche Potatso, quindi usa l'ID esattamente come lo fornisce il tuo provider.

## Trasporti {#transports}

| Trasporto | `type` del link | Supportato | Testato con |
| --- | --- | --- | --- |
| Nessun trasporto (TCP grezzo) | `tcp`, `raw`, o nessuno | ✅ | Xray, sing-box |
| WebSocket | `ws` | ✅ Con o senza early data | Xray, sing-box |
| gRPC | `grpc` | ✅ | Xray, sing-box |
| HTTP Upgrade | `httpupgrade` | ✅ | Xray, sing-box |
| [XHTTP](#xhttp) | `xhttp`, `splithttp` | ✅ In modalità `stream-one` e `auto` | Xray |
| HTTP/2 | `http` o `h2` | ✅ | sing-box |
| mKCP | `kcp` | ❌ | |
| QUIC | `quic` | ❌ | |
| TCP con offuscamento dell'intestazione HTTP | `tcp` con `headerType=http` | ❌ | |

Ogni trasporto funziona con e senza TLS, e con UDP. Potatso non importa un server il cui trasporto non supporta.

Xray non offre più HTTP/2 né QUIC: i server Xray che li usavano ora usano XHTTP.

### XHTTP {#xhttp}

XHTTP (in precedenza SplitHTTP) ha diverse modalità. Potatso invia l'intera connessione come un'unica richiesta HTTP (`stream-one`). Un server Xray la accetta nella sua modalità predefinita `auto` e nelle modalità `stream-one` e `stream-up`, quindi funziona un link con `mode=auto`, o senza modalità.

Potatso non supporta le modalità client `packet-up` e `stream-up`, e non importa un link che le richiede. Il parametro `extra` di un link XHTTP non è supportato: Potatso lo ignora. Potatso modifica i server XHTTP con TLS o REALITY; un server XHTTP importato senza TLS funziona comunque.

## Sicurezza {#security}

| Sicurezza | `security` del link | Supportata |
| --- | --- | --- |
| Nessuna | `none`, o nessuno | ✅ Il tuo traffico non è cifrato, a meno che il server non usi [VLESS Encryption](#encryption). |
| TLS | `tls` | ✅ |
| [REALITY](#reality) | `reality` | ✅ Senza trasporto, con gRPC o XHTTP |

### Impostazioni TLS {#tls}

| Impostazione | Chiave Clash | Parametro del link | Supportata |
| --- | --- | --- | --- |
| Nome del server (SNI) | `servername` | `sni` | ✅ Senza di esso, Potatso usa l'indirizzo del server. |
| ALPN | `alpn` | `alpn` | ✅ Senza di esso, Potatso invia `http/1.1` per WebSocket, `h2` per gRPC, HTTP/2 e XHTTP, e nulla per gli altri. |
| Salta verifica certificato | `skip-cert-verify` | `allowInsecure`, `insecure` | ✅ |
| Pin del certificato (SHA-256) | `fingerprint` | `pcs` | ✅ Un certificato |
| Verifica del certificato per un altro nome | | `vcn` | ❌ Potatso controlla il certificato rispetto al nome del server. |
| Impronta del browser | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` e `random`. Gli altri nomi si connettono con un handshake predefinito. |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ✅ Con la configurazione ECH nel link o nella sottoscrizione |
| Certificato CA personalizzato | | | ❌ |
| Certificato client TLS | `certificate`, `private-key` | | ❌ |

Disattivare la verifica del certificato permette a chiunque si trovi tra te e il server di leggere il tuo traffico. Se il server usa un certificato autofirmato, fissa invece il certificato: imposta lo SHA-256 del suo certificato come pin del certificato. Potatso fissa un solo certificato; non importa un link che ne elenca diversi in `pcs`.

Un'impronta del browser fa sì che l'handshake TLS della connessione somigli a quello di quel browser. Non cambia ciò che il server deve supportare.

### REALITY {#reality}

Un server REALITY prende in prestito il certificato TLS di un altro sito web, quindi non ne ha bisogno di uno proprio. Imposta la **chiave pubblica** e lo **short ID** del server come te li dà il tuo provider, e il nome del server sul sito web da cui il server prende il certificato in prestito. Lo `spx` del link (spider path) non serve per connettersi, e Potatso lo ignora.

REALITY richiede un'impronta del browser: quando il tuo link o le tue impostazioni non ne hanno una, Potatso usa `chrome`. Con REALITY, anche `android` e i nomi che Potatso non conosce si connettono come `chrome`.

REALITY funziona senza trasporto, con gRPC e con XHTTP.

## Flusso Vision {#vision}

| Flusso | `flow` del link | Supportato |
| --- | --- | --- |
| Nessuno | nessuno | ✅ |
| Vision | `xtls-rprx-vision` | ✅ |
| Vision, UDP 443 consentito | `xtls-rprx-vision-udp443` | ✅ |
| `xtls-rprx-direct`, `xtls-rprx-splice` e altri vecchi flussi XTLS | | ❌ Xray li ha rimossi |

Vision funziona solo senza trasporto e con TLS o REALITY: Potatso non salva né importa un server Vision con un altro trasporto o senza TLS. Funziona anche con VLESS Encryption sopra TLS.

Con Vision, UDP viene trasportato come lo trasporta Xray, tramite Mux.Cool, che accettano sia i server Xray sia sing-box. Il client di Xray rifiuta UDP verso la porta 443 (QUIC) con `xtls-rprx-vision`, in modo che i browser ripieghino su TCP; Potatso lo trasporta con entrambi i flussi.

## VLESS Encryption {#encryption}

VLESS Encryption (`mlkem768x25519plus`) è il livello di cifratura post-quantistico di Xray: uno scambio di chiavi ML-KEM-768 e X25519 sotto la connessione VLESS. L'impostazione `decryption` del server ha un valore `encryption` corrispondente per i client, fatto così:

```text
mlkem768x25519plus.native.0rtt.<key>
```

| Impostazione | Supportata |
| --- | --- |
| Modalità `native`, `xorpub` e `random` | ✅ |
| `1rtt` e `0rtt` (connessioni riprese) | ✅ |
| Server autenticato con una chiave X25519 o ML-KEM-768 | ✅ |
| Senza trasporto e senza TLS | ✅ |
| Sopra TLS | ✅ Anche con Vision |
| Vision senza TLS | ❌ |

Potatso mantiene il valore `encryption` di un link, di una sottoscrizione Clash o di una configurazione Xray. Non puoi ancora digitarne uno nelle impostazioni del server.

## Multiplexing {#mux}

Potatso può far passare più connessioni su una sola connessione VLESS, impostato con `smux` in una sottoscrizione Clash:

| Protocollo | `smux.protocol` di Clash | Server | Supportato |
| --- | --- | --- | --- |
| Mux.Cool (Xray) | `muxcool` | Xray, sing-box | ✅ TCP e UDP |
| Multiplexing di sing-box | `smux`, `yamux`, `h2mux` | sing-box, con il multiplexing attivo | ✅ TCP e UDP, con o senza padding |

Con Vision, Mux.Cool trasporta solo UDP e ogni connessione TCP mantiene la propria connessione, come in Xray. Il multiplexing di sing-box non funziona con Vision, e Potatso non importa un server Vision che lo richiede.

Le impostazioni `mux` di Xray in una configurazione Xray non vengono importate.

## UDP {#udp}

VLESS trasporta UDP sulla stessa connessione di TCP. UDP è disattivato per impostazione predefinita, come in Clash. Attiva Relay UDP nelle impostazioni del server se il tuo server inoltra UDP: lo fanno sia Xray sia sing-box. Una sottoscrizione Clash lo attiva con `udp: true`.

Ogni flusso UDP ha la propria connessione al server, e ogni destinazione il proprio flusso. Potatso non supporta XUDP né packetaddr (`packetEncoding` in un link, `packet-encoding` o `xudp` in una sottoscrizione): i server accettano l'UDP di Potatso senza di essi, e Potatso ignora l'impostazione.

## Funzioni supportate {#features}

| Funzione | Supportata |
| --- | --- |
| [Protocollo VLESS](https://xtls.github.io/en/development/protocols/vless.html) versione 0: comandi TCP e UDP | ✅ |
| ID utente UUID e testuali | ✅ |
| Più utenti su un server | ✅ Ciascuno con il proprio ID |
| Flusso Vision (`xtls-rprx-vision`, `-udp443`) | ✅ Vedi [Vision](#vision) |
| VLESS Encryption (`mlkem768x25519plus`) | ✅ Vedi [VLESS Encryption](#encryption) |
| TLS, REALITY, ECH, pin del certificato, impronte del browser | ✅ Vedi [Sicurezza](#security) |
| Trasporti WebSocket, gRPC, HTTP Upgrade, HTTP/2 | ✅ Vedi [Trasporti](#transports) |
| XHTTP | Modalità `stream-one` e `auto` |
| mKCP, QUIC, offuscamento dell'intestazione HTTP su TCP | ❌ |
| Mux.Cool | ✅ |
| XUDP, packetaddr | ❌ UDP usa il semplice comando UDP |
| Multiplexing di sing-box (smux, yamux, h2mux) | ✅ |
| Proxy inverso (`reverse` di VLESS) | ❌ È una funzione del server |
| Link `vless://` ([standard dei link di condivisione Xray](https://github.com/XTLS/Xray-core/discussions/716)) | ✅ |

## Link `vless://` {#links}

Un link `vless://` contiene un intero server in una riga:

```text
vless://id@host:port?type=…&security=…&…#name
```

| Parte | Descrizione |
| --- | --- |
| `id` | L'ID utente. |
| `host` | Indirizzo del server. Metti un indirizzo IPv6 tra parentesi quadre, come `[2001:db8::1]`. |
| `port` | Porta del server. |
| `encryption` | `none`, oppure un valore di [VLESS Encryption](#encryption). |
| `flow` | Facoltativo. `xtls-rprx-vision` o `xtls-rprx-vision-udp443`. |
| `type` | Il [trasporto](#transports). |
| `security` | `none`, `tls` o `reality`. |
| `sni`, `alpn`, `fp`, `pcs`, `ech`, `allowInsecure` | [Impostazioni TLS](#tls). |
| `pbk`, `sid` | La chiave pubblica e lo short ID di REALITY. |
| `host`, `path` | L'intestazione `Host` e il percorso di WebSocket, HTTP Upgrade, HTTP/2 e XHTTP. Un percorso WebSocket può portare early data come `?ed=2048`. |
| `serviceName` | Il nome del servizio gRPC. |
| `mode` | La modalità XHTTP. |
| `name` | Facoltativo. Il nome del server in Potatso. |

Quando Potatso condivide un server VLESS, scrive un link in questa forma.

### Esempi {#link-examples}

Ogni esempio mostra il link da importare. L'ID utente è `3971e1b2-18a3-4f83-8fa6-bf9b142ee258`.

TLS senza trasporto:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&sni=vless.example.com&type=tcp#TLS
```

REALITY con Vision, con `www.example.com` preso in prestito:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=reality&sni=www.example.com&fp=chrome&pbk=Z84J2IelR9ch3k8VtlVhhs5ycBUlXA7wHBWcBrjqnAw&sid=0123abcd&type=tcp&flow=xtls-rprx-vision#REALITY-Vision
```

WebSocket su TLS tramite una CDN, con 2048 byte di early data:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=ws&host=cdn.example.com&path=%2Fws%3Fed%3D2048#WebSocket
```

gRPC su TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=grpc&serviceName=gun#gRPC
```

HTTP Upgrade su TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=httpupgrade&host=cdn.example.com&path=%2Fup#HTTPUpgrade
```

XHTTP su TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=xhttp&host=cdn.example.com&path=%2Fxh&mode=auto#XHTTP
```

HTTP/2 su TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=http&host=cdn.example.com&path=%2Fh2#HTTP2
```

VLESS Encryption senza TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:8443?security=none&encryption=mlkem768x25519plus.native.0rtt.u7dtLE6KgE4mjeBK3oYdNMw6MJB47Ijr_9AG2avwSmY&type=tcp#Encryption
```

Source: https://potatso.com/docs/it/protocols/vless/index.mdx