---
title: "VMess"
description: "Les chiffrements, transports, liens et fonctionnalités VMess pris en charge par 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 serveur VMess se décrit par un **UUID**, un **chiffrement** qui protège le trafic et un **transport** qui porte la connexion, comme WebSocket ou gRPC, avec ou sans TLS. Potatso se connecte à un serveur lorsqu’il prend en charge son chiffrement, son transport et ses réglages TLS. Utilisez les tableaux ci-dessous pour vérifier les réglages de votre serveur, tels que votre fournisseur les indique ou tels qu’ils figurent dans son lien `vmess://`.

Vous pouvez ajouter un serveur VMess à la main, avec un [lien `vmess://`](#links), ou en important :

- un abonnement Clash ou Mihomo,
- une configuration Xray ou V2Ray,
- une configuration Surge.

Potatso n’importe pas encore les serveurs VMess d’une configuration sing-box. Utilisez plutôt le lien `vmess://` du serveur.

## Chiffrements {#ciphers}

| Chiffrement | Pris en charge |
| --- | --- |
| `auto` | ✅ Potatso choisit `aes-128-gcm`, que tous les appareils Apple exécutent en matériel. |
| `aes-128-gcm` | ✅ |
| `chacha20-poly1305` | ✅ |
| `none` | ✅ |
| `zero` | ❌ |
| `aes-128-cfb` (ancien) | ❌ |

`none` et `zero` envoient votre trafic sans chiffrement. N’utilisez `none` qu’avec TLS, qui chiffre alors la connexion. Potatso ne se connecte pas avec `zero`, qui supprime aussi la protection contre la falsification : choisissez un autre chiffrement sur votre serveur.

### alterId {#alterid}

Potatso utilise toujours l’authentification VMess actuelle, identique à `alterId` 0. Les serveurs dont l’utilisateur a encore un `alterId` supérieur à 0 l’acceptent aussi : vous pouvez donc laisser le serveur tel quel. Potatso ne prend pas en charge l’ancienne authentification que seul un `alterId` supérieur à 0 utilisait, que les serveurs ont abandonnée depuis 2022.

## Transports {#transports}

| Transport | `net` / `type` du lien | Pris en charge | Testé avec |
| --- | --- | --- | --- |
| Aucun (TCP simple) | `tcp`, ou aucun | ✅ Avec ou sans TLS | Xray, sing-box, V2Ray |
| WebSocket | `ws` | ✅ Avec ou sans TLS et early data | Xray, sing-box, V2Ray |
| gRPC | `grpc` | ✅ Avec ou sans TLS | Xray, sing-box, V2Ray |
| HTTP/2 | `h2` ou `http` | ✅ Avec TLS | sing-box, V2Ray |
| HTTP Upgrade | `httpupgrade` | ✅ Avec ou sans TLS | Xray, sing-box |
| TCP avec un en-tête HTTP | `tcp` avec `type=http` | ❌ | |
| XHTTP | `xhttp` | ❌ | |
| mKCP, QUIC | `kcp`, `quic` | ❌ | |

Chaque transport pris en charge fonctionne avec l’UDP. Potatso n’importe pas un serveur dont il ne prend pas en charge le transport.

L’early data WebSocket envoie les premiers octets d’une connexion avec la négociation WebSocket, ce qui économise un aller-retour. Elle se définit par `?ed=2048` à la fin du chemin du lien, ou `max-early-data` dans un abonnement Clash.

Xray ne propose plus HTTP/2 : les serveurs Xray qui l’utilisaient utilisent désormais XHTTP, que Potatso ne prend pas encore en charge.

## TLS {#tls}

| Réglage | Clé Clash | Champ de lien | Pris en charge |
| --- | --- | --- | --- |
| Nom du serveur (SNI) | `servername` | `sni` | ✅ Sans nom, Potatso utilise l’adresse du serveur. |
| ALPN | `alpn` | `alpn` | ✅ Sans ALPN, Potatso envoie `http/1.1` pour WebSocket et `h2` pour gRPC et HTTP/2. |
| Ignorer la vérification du certificat | `skip-cert-verify` | `allowInsecure` | ✅ |
| Empreinte de navigateur | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` et `random`. Les autres noms se connectent avec une négociation par défaut. |
| Épinglage de certificat | `fingerprint` | `pcs` | ❌ |
| REALITY | `reality-opts` | `security=reality` | ❌ |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ❌ |
| Certificat CA personnalisé | | | ❌ |

Désactiver la vérification du certificat permet à n’importe qui entre vous et le serveur de lire votre trafic. Potatso ne se connecte pas à un serveur VMess qui exige REALITY, ECH ou un épinglage de certificat, car se connecter sans eux n’offrirait pas la protection que demande le serveur. Utilisez VLESS ou Trojan pour REALITY.

Une empreinte de navigateur fait ressembler la négociation TLS de la connexion à celle de ce navigateur. Elle ne change pas ce que le serveur doit prendre en charge.

## UDP {#udp}

L’UDP est désactivé par défaut pour les serveurs VMess. Activez **Relais UDP** dans les réglages du serveur, ou définissez `udp: true` dans un abonnement Clash.

Potatso envoie chaque flux UDP sur sa propre connexion VMess, ce que tous les serveurs VMess acceptent. Il ne prend pas en charge les encodages XUDP et PacketAddr (`packetEncoding` dans un lien, `packet-encoding` ou `xudp` dans un abonnement Clash), qui transportent plusieurs flux UDP sur une seule connexion : un serveur configuré avec eux fonctionne quand même, et Potatso vous indique à l’import qu’il utilise son propre UDP à la place. Les apps qui ont besoin d’un NAT full-cone, comme certains jeux, peuvent ne pas fonctionner avec lui.

Avec le [multiplexage](#mux) activé, l’UDP passe par la connexion partagée.

## Multiplexage {#mux}

Potatso peut faire passer plusieurs connexions par une seule connexion VMess, défini avec `smux` dans un abonnement Clash :

| Protocole | `protocol` de `smux` | Serveurs |
| --- | --- | --- |
| Mux.Cool | `muxcool` | Xray, V2Ray et sing-box, sans réglage serveur |
| sing-mux | `h2mux`, `smux`, `yamux` | sing-box avec le multiplexage activé |

Le TCP et l’UDP fonctionnent tous deux. Mux.Cool ferme les deux sens d’une connexion ensemble : une app qui cesse d’envoyer puis attend la réponse doit donc utiliser un serveur sans multiplexage.

## Options de requête {#request-options}

Un client VMess choisit quelques options pour chaque connexion, et chaque serveur les accepte toutes. Potatso envoie toujours son trafic en blocs chiffrés et marque la fin de chaque envoi, et ne définit pas les autres :

| Option | Clé Clash | Potatso |
| --- | --- | --- |
| Flux de blocs | | Toujours activé |
| Masquage des blocs | | Désactivé |
| Bourrage global | `global-padding` | Désactivé. Potatso vous avertit quand vous importez un serveur qui le définit. |
| Longueur authentifiée | `authenticated-length` | Désactivé. Potatso vous avertit quand vous importez un serveur qui la définit. |

Le masquage des blocs et le bourrage global cachent la taille de chaque bloc à quiconque observe. Sans eux, votre trafic reste illisible, mais son motif est plus facile à reconnaître.

### Gros envois {#large-uploads}

Une seule connexion VMess peut envoyer environ 1 Gio. VMess numérote ses blocs chiffrés avec un compteur qui s’épuise après cela, et continuer affaiblirait le chiffrement : Potatso ferme donc la connexion. Les téléchargements n’ont pas de limite. Pour des envois de plus de 1 Gio sur une seule connexion, utilisez un serveur VLESS ou Trojan.

## Fonctionnalités prises en charge {#features}

| Fonctionnalité | Pris en charge |
| --- | --- |
| [Authentification AEAD](https://www.v2fly.org/en_US/developer/protocols/vmess.html) (`alterId` 0) | ✅ |
| Ancienne authentification MD5 (`alterId` supérieur à 0) | ❌ Les serveurs avec `alterId` supérieur à 0 acceptent l’authentification AEAD. |
| Chiffrements `aes-128-gcm`, `chacha20-poly1305`, `none`, `auto` | ✅ |
| Chiffrements `zero` et l’ancien `aes-128-cfb` | ❌ |
| Flux de blocs, marqueur de fin d’envoi | ✅ |
| Masquage des blocs, bourrage global, longueur authentifiée | ❌ Les serveurs acceptent les connexions sans eux |
| UDP | ✅ Une connexion par flux |
| Envois de plus d’environ 1 Gio sur une connexion | ❌ Voir [Gros envois](#large-uploads) |
| XUDP, PacketAddr | ❌ |
| Mux.Cool | ✅ TCP et UDP |
| sing-mux (h2mux, smux, yamux) | ✅ TCP et UDP |
| Transports | Voir [Transports](#transports) |
| TLS | Voir [TLS](#tls) |
| [Liens de partage v2rayN](#links) (version 2) | ✅ |
| [Liens de partage Xray](https://github.com/XTLS/Xray-core/discussions/716) | ✅ |
| Liens de partage Shadowrocket | Import uniquement |

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

Un lien `vmess://` contient un serveur entier sur une ligne. Potatso importe trois formes et partage les deux premières.

La forme v2rayN, la plus courante, est un objet JSON encodé en Base64 :

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

| Champ | Description |
| --- | --- |
| `v` | Version du format, `2`. |
| `ps` | Facultatif. Le nom du serveur dans Potatso. |
| `add` | Adresse du serveur. |
| `port` | Port du serveur. |
| `id` | L’UUID. |
| `aid` | `alterId`. Voir [alterId](#alterid). |
| `scy` | Le [chiffrement](#ciphers). Sans valeur, `auto`. |
| `net` | Le [transport](#transports) : `tcp`, `ws`, `grpc`, `h2` ou `httpupgrade`. |
| `type` | `none`, ou `http` pour un en-tête HTTP en TCP, que Potatso ne prend pas en charge. |
| `host` | L’en-tête `Host` pour WebSocket, HTTP/2 et HTTP Upgrade. |
| `path` | Le chemin pour WebSocket, HTTP/2 et HTTP Upgrade, ou le nom du service pour gRPC. Un chemin WebSocket peut se terminer par `?ed=2048` pour l’early data. |
| `tls` | `tls` pour utiliser TLS, ou vide. |
| `sni`, `alpn`, `fp` | Le nom du serveur [TLS](#tls), la liste ALPN et l’empreinte de navigateur. |

La forme Xray est une URL, avec le chiffrement dans `encryption` et les réglages de transport et de TLS comme paramètres de requête :

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

| Paramètre | Description |
| --- | --- |
| `type` | Le [transport](#transports). |
| `encryption` | Le [chiffrement](#ciphers). Sans valeur, `auto`. |
| `security` | `tls`, ou `none`. |
| `sni`, `alpn`, `fp` | Le nom du serveur [TLS](#tls), la liste ALPN et l’empreinte de navigateur. |
| `host`, `path` | L’en-tête `Host` et le chemin, comme dans la forme v2rayN. |
| `serviceName` | Le nom du service gRPC. |
| `ed` | L’early data WebSocket, en octets. |

Potatso importe aussi la forme de Shadowrocket, `vmess://base64(cipher:uuid@host:port)?remarks=…&obfs=websocket&…`.

### Exemples {#link-examples}

Chaque exemple montre le lien à importer. L’UUID est `b831381d-6324-4d53-ad4f-8cda48b30811`.

WebSocket avec TLS et early data, via `cdn.example.com`, avec l’empreinte Chrome :

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

gRPC avec TLS et `aes-128-gcm`, nom de service `vmess-grpc` :

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

TCP simple avec `chacha20-poly1305`, dans la forme Xray :

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

HTTP Upgrade avec TLS, dans la forme 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
```

### Dans un abonnement 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/fr/protocols/vmess/index.mdx