---
title: "VMess"
description: "Le cifrature, i trasporti, i link e le funzioni di VMess 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.

# VMess

Un server VMess è descritto da un **UUID**, da una **cifratura** che protegge il traffico e da un **trasporto** che porta la connessione, come WebSocket o gRPC, con o senza TLS. Potatso si connette a un server quando supporta la cifratura, il trasporto e le impostazioni TLS del server. Usa le tabelle qui sotto per controllare le impostazioni del tuo server, come le indica il tuo provider o come compaiono nel suo link `vmess://`.

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

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

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

## Cifrature {#ciphers}

| Cifratura | Supportata |
| --- | --- |
| `auto` | ✅ Potatso sceglie `aes-128-gcm`, che ogni dispositivo Apple esegue in hardware. |
| `aes-128-gcm` | ✅ |
| `chacha20-poly1305` | ✅ |
| `none` | ✅ |
| `zero` | ❌ |
| `aes-128-cfb` (legacy) | ❌ |

`none` e `zero` inviano il tuo traffico senza cifratura. Usa `none` solo con TLS, che allora cifra la connessione. Potatso non si connette con `zero`, che elimina anche la protezione contro le manomissioni: scegli un'altra cifratura sul tuo server.

### alterId {#alterid}

Potatso usa sempre l'autenticazione VMess attuale, che equivale a `alterId` 0. Anche i server il cui utente ha ancora un `alterId` superiore a 0 la accettano, quindi puoi lasciare il server com'è. Potatso non supporta la vecchia autenticazione usata solo con `alterId` superiore a 0, che i server hanno dichiarato obsoleta dal 2022.

## Trasporti {#transports}

| Trasporto | `net` / `type` del link | Supportato | Testato con |
| --- | --- | --- | --- |
| Nessuno (TCP semplice) | `tcp`, o nessuno | ✅ Con o senza TLS | Xray, sing-box, V2Ray |
| WebSocket | `ws` | ✅ Con o senza TLS e early data | Xray, sing-box, V2Ray |
| gRPC | `grpc` | ✅ Con o senza TLS | Xray, sing-box, V2Ray |
| HTTP/2 | `h2` o `http` | ✅ Con TLS | sing-box, V2Ray |
| HTTP Upgrade | `httpupgrade` | ✅ Con o senza TLS | Xray, sing-box |
| TCP con un'intestazione HTTP | `tcp` con `type=http` | ❌ | |
| XHTTP | `xhttp` | ❌ | |
| mKCP, QUIC | `kcp`, `quic` | ❌ | |

Ogni trasporto supportato funziona con UDP. Potatso non importa un server il cui trasporto non supporta.

L'early data di WebSocket invia i primi byte di una connessione insieme all'handshake WebSocket, risparmiando un round trip. Si imposta con `?ed=2048` alla fine del percorso del link, oppure con `max-early-data` in una sottoscrizione Clash.

Xray non offre più HTTP/2: i server Xray che lo usavano ora usano XHTTP, che Potatso non supporta ancora.

## TLS {#tls}

| Impostazione | Chiave Clash | Campo 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 e `h2` per gRPC e HTTP/2. |
| Salta verifica certificato | `skip-cert-verify` | `allowInsecure` | ✅ |
| Impronta del browser | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` e `random`. Gli altri nomi si connettono con un handshake predefinito. |
| Pin del certificato | `fingerprint` | `pcs` | ❌ |
| REALITY | `reality-opts` | `security=reality` | ❌ |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ❌ |
| Certificato CA personalizzato | | | ❌ |

Disattivare la verifica del certificato permette a chiunque si trovi tra te e il server di leggere il tuo traffico. Potatso non si connette a un server VMess che richiede REALITY, ECH o un pin del certificato, perché connettersi senza di essi non darebbe la protezione richiesta dal server. Usa VLESS o Trojan per REALITY.

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.

## UDP {#udp}

UDP è disattivato per impostazione predefinita per i server VMess. Attiva **Relay UDP** nelle impostazioni del server, oppure imposta `udp: true` in una sottoscrizione Clash.

Potatso invia ogni flusso UDP su una propria connessione VMess, cosa che ogni server VMess accetta. Non supporta le codifiche XUDP e PacketAddr (`packetEncoding` in un link, `packet-encoding` o `xudp` in una sottoscrizione Clash), che trasportano molti flussi UDP su una sola connessione: un server configurato con esse funziona comunque, e Potatso ti avvisa all'importazione che usa invece il proprio UDP. Le app che richiedono full-cone NAT, come alcuni giochi, potrebbero non funzionare.

Con il [multiplexing](#mux) attivo, UDP viaggia invece sulla connessione condivisa.

## Multiplexing {#mux}

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

| Protocollo | `protocol` di `smux` | Server |
| --- | --- | --- |
| Mux.Cool | `muxcool` | Xray, V2Ray e sing-box, senza alcuna impostazione sul server |
| sing-mux | `h2mux`, `smux`, `yamux` | sing-box con il multiplexing attivo |

Funzionano sia TCP sia UDP. Mux.Cool chiude insieme entrambe le direzioni di una connessione, quindi un'app che smette di inviare e poi aspetta la risposta dovrebbe usare un server senza multiplexing.

## Opzioni della richiesta {#request-options}

Un client VMess sceglie alcune opzioni per ogni connessione, e ogni server le accetta tutte. Potatso invia sempre il suo traffico in blocchi cifrati e segna la fine di ogni upload, e non imposta le altre:

| Opzione | Chiave Clash | Potatso |
| --- | --- | --- |
| Flusso a blocchi | | Sempre attivo |
| Mascheramento dei blocchi | | Disattivato |
| Padding globale | `global-padding` | Disattivato. Potatso ti avvisa quando importi un server che lo imposta. |
| Lunghezza autenticata | `authenticated-length` | Disattivata. Potatso ti avvisa quando importi un server che la imposta. |

Il mascheramento dei blocchi e il padding globale nascondono a chi osserva la dimensione di ogni blocco. Senza di essi, il tuo traffico resta comunque illeggibile, ma il suo schema è più facile da riconoscere.

### Upload di grandi dimensioni {#large-uploads}

Una singola connessione VMess può caricare circa 1 GiB. VMess numera i suoi blocchi cifrati con un contatore che si esaurisce dopo quella quantità, e proseguire indebolirebbe la cifratura, quindi Potatso chiude invece la connessione. I download non hanno limiti. Per upload superiori a 1 GiB in una sola connessione, usa un server VLESS o Trojan.

## Funzioni supportate {#features}

| Funzione | Supportata |
| --- | --- |
| [Autenticazione AEAD](https://www.v2fly.org/en_US/developer/protocols/vmess.html) (`alterId` 0) | ✅ |
| Autenticazione MD5 legacy (`alterId` superiore a 0) | ❌ I server con `alterId` superiore a 0 accettano l'autenticazione AEAD. |
| Cifrature `aes-128-gcm`, `chacha20-poly1305`, `none`, `auto` | ✅ |
| Cifrature `zero` e la legacy `aes-128-cfb` | ❌ |
| Flusso a blocchi, marcatore di fine upload | ✅ |
| Mascheramento dei blocchi, padding globale, lunghezza autenticata | ❌ I server accettano connessioni senza di essi |
| UDP | ✅ Una connessione per flusso |
| Upload oltre circa 1 GiB su una connessione | ❌ Vedi [Upload di grandi dimensioni](#large-uploads) |
| XUDP, PacketAddr | ❌ |
| Mux.Cool | ✅ TCP e UDP |
| sing-mux (h2mux, smux, yamux) | ✅ TCP e UDP |
| Trasporti | Vedi [Trasporti](#transports) |
| TLS | Vedi [TLS](#tls) |
| [Link di condivisione v2rayN](#links) (versione 2) | ✅ |
| [Link di condivisione Xray](https://github.com/XTLS/Xray-core/discussions/716) | ✅ |
| Link di condivisione Shadowrocket | Solo importazione |

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

Un link `vmess://` contiene un intero server in una riga. Potatso importa tre forme e ne condivide le prime due.

La forma v2rayN, la più comune, è un oggetto JSON codificato in Base64:

```text
vmess://base64({"v":"2","ps":"name","add":"host","port":"443","id":"uuid",…})
```

| Campo | Descrizione |
| --- | --- |
| `v` | Versione del formato, `2`. |
| `ps` | Facoltativo. Il nome del server in Potatso. |
| `add` | Indirizzo del server. |
| `port` | Porta del server. |
| `id` | L'UUID. |
| `aid` | `alterId`. Vedi [alterId](#alterid). |
| `scy` | La [cifratura](#ciphers). Senza di essa, `auto`. |
| `net` | Il [trasporto](#transports): `tcp`, `ws`, `grpc`, `h2` o `httpupgrade`. |
| `type` | `none`, oppure `http` per un'intestazione HTTP su TCP, che Potatso non supporta. |
| `host` | L'intestazione `Host` per WebSocket, HTTP/2 e HTTP Upgrade. |
| `path` | Il percorso per WebSocket, HTTP/2 e HTTP Upgrade, oppure il nome del servizio per gRPC. Un percorso WebSocket può terminare con `?ed=2048` per l'early data. |
| `tls` | `tls` per usare TLS, oppure vuoto. |
| `sni`, `alpn`, `fp` | Il nome del server [TLS](#tls), l'elenco ALPN e l'impronta del browser. |

La forma Xray è un URL, con la cifratura in `encryption` e le impostazioni del trasporto e di TLS come parametri di query:

```text
vmess://uuid@host:port?type=ws&security=tls&sni=…&host=…&path=…&encryption=auto#name
```

| Parametro | Descrizione |
| --- | --- |
| `type` | Il [trasporto](#transports). |
| `encryption` | La [cifratura](#ciphers). Senza di essa, `auto`. |
| `security` | `tls`, oppure `none`. |
| `sni`, `alpn`, `fp` | Il nome del server [TLS](#tls), l'elenco ALPN e l'impronta del browser. |
| `host`, `path` | L'intestazione `Host` e il percorso, come nella forma v2rayN. |
| `serviceName` | Il nome del servizio gRPC. |
| `ed` | L'early data di WebSocket, in byte. |

Potatso importa anche la forma di Shadowrocket, `vmess://base64(cipher:uuid@host:port)?remarks=…&obfs=websocket&…`.

### Esempi {#link-examples}

Ogni esempio mostra il link da importare. L'UUID è `b831381d-6324-4d53-ad4f-8cda48b30811`.

WebSocket con TLS e early data, tramite `cdn.example.com`, con l'impronta Chrome:

```text
vmess://eyJ2IjoiMiIsInBzIjoiV1MgVExTIiwiYWRkIjoidm1lc3MuZXhhbXBsZS5jb20iLCJwb3J0IjoiNDQzIiwiaWQiOiJiODMxMzgxZC02MzI0LTRkNTMtYWQ0Zi04Y2RhNDhiMzA4MTEiLCJhaWQiOiIwIiwic2N5IjoiYXV0byIsIm5ldCI6IndzIiwidHlwZSI6Im5vbmUiLCJob3N0IjoiY2RuLmV4YW1wbGUuY29tIiwicGF0aCI6Ii9yYXk/ZWQ9MjA0OCIsInRscyI6InRscyIsInNuaSI6ImNkbi5leGFtcGxlLmNvbSIsImFscG4iOiJodHRwLzEuMSIsImZwIjoiY2hyb21lIn0=
```

gRPC con TLS e `aes-128-gcm`, nome del servizio `vmess-grpc`:

```text
vmess://eyJ2IjoiMiIsInBzIjoiZ1JQQyIsImFkZCI6InZtZXNzLmV4YW1wbGUuY29tIiwicG9ydCI6IjQ0MyIsImlkIjoiYjgzMTM4MWQtNjMyNC00ZDUzLWFkNGYtOGNkYTQ4YjMwODExIiwiYWlkIjoiMCIsInNjeSI6ImFlcy0xMjgtZ2NtIiwibmV0IjoiZ3JwYyIsInBhdGgiOiJ2bWVzcy1ncnBjIiwidGxzIjoidGxzIiwic25pIjoidm1lc3MuZXhhbXBsZS5jb20ifQ==
```

TCP semplice con `chacha20-poly1305`, nella forma Xray:

```text
vmess://b831381d-6324-4d53-ad4f-8cda48b30811@vmess.example.com:8080?type=tcp&encryption=chacha20-poly1305#Plain%20TCP
```

HTTP Upgrade con TLS, nella forma Xray:

```text
vmess://b831381d-6324-4d53-ad4f-8cda48b30811@vmess.example.com:443?type=httpupgrade&security=tls&sni=cdn.example.com&host=cdn.example.com&path=%2Fupgrade&encryption=auto#HTTP%20Upgrade
```

### In una sottoscrizione Clash {#clash}

```yaml
proxies:
  - name: VMess WS
    type: vmess
    server: vmess.example.com
    port: 443
    uuid: b831381d-6324-4d53-ad4f-8cda48b30811
    alterId: 0
    cipher: auto
    udp: true
    tls: true
    servername: cdn.example.com
    network: ws
    ws-opts:
      path: /ray
      headers:
        Host: cdn.example.com
      max-early-data: 2048
      early-data-header-name: Sec-WebSocket-Protocol
```

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