---
title: "VMess"
description: "Die von Potatso unterstützten VMess-Verschlüsselungen, Transporte, Links und Funktionen."
---

> 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

Ein VMess-Server wird durch eine **UUID**, eine **Verschlüsselung**, die den Datenverkehr verschlüsselt, und einen **Transport** beschrieben, der die Verbindung trägt, etwa WebSocket oder gRPC, mit oder ohne TLS. Potatso verbindet sich mit einem Server, wenn es dessen Verschlüsselung, Transport und TLS-Einstellungen unterstützt. Prüfe anhand der Tabellen unten die Einstellungen deines Servers, wie dein Anbieter sie angibt oder wie sie in seinem `vmess://`-Link stehen.

Einen VMess-Server kannst du von Hand, mit einem [`vmess://`-Link](#links) oder per Import hinzufügen:

- eines Clash- oder Mihomo-Abonnements,
- einer Xray- oder V2Ray-Konfiguration,
- einer Surge-Konfiguration.

Potatso importiert VMess-Server noch nicht aus einer sing-box-Konfiguration. Nutze stattdessen den `vmess://`-Link des Servers.

## Verschlüsselungen {#ciphers}

| Verschlüsselung | Unterstützt |
| --- | --- |
| `auto` | ✅ Potatso wählt `aes-128-gcm`, das jedes Apple-Gerät in Hardware ausführt. |
| `aes-128-gcm` | ✅ |
| `chacha20-poly1305` | ✅ |
| `none` | ✅ |
| `zero` | ❌ |
| `aes-128-cfb` (veraltet) | ❌ |

`none` und `zero` senden deinen Datenverkehr unverschlüsselt. Nutze `none` nur mit TLS, das die Verbindung dann verschlüsselt. Mit `zero`, das auch den Schutz vor Manipulation aufgibt, verbindet Potatso nicht: Wähle auf deinem Server eine andere Verschlüsselung.

### alterId {#alterid}

Potatso verwendet immer die aktuelle VMess-Authentifizierung, die `alterId` 0 entspricht. Server, deren Benutzer noch eine `alterId` über 0 hat, akzeptieren sie ebenfalls, du kannst den Server also so lassen, wie er ist. Potatso unterstützt die alte Authentifizierung nicht, die nur `alterId` über 0 nutzte und die Server seit 2022 als veraltet führen.

## Transporte {#transports}

| Transport | Link-`net` / `type` | Unterstützt | Getestet mit |
| --- | --- | --- | --- |
| Keiner (einfaches TCP) | `tcp` oder keiner | ✅ Mit oder ohne TLS | Xray, sing-box, V2Ray |
| WebSocket | `ws` | ✅ Mit oder ohne TLS und Early Data | Xray, sing-box, V2Ray |
| gRPC | `grpc` | ✅ Mit oder ohne TLS | Xray, sing-box, V2Ray |
| HTTP/2 | `h2` oder `http` | ✅ Mit TLS | sing-box, V2Ray |
| HTTP Upgrade | `httpupgrade` | ✅ Mit oder ohne TLS | Xray, sing-box |
| TCP mit einem HTTP-Header | `tcp` mit `type=http` | ❌ | |
| XHTTP | `xhttp` | ❌ | |
| mKCP, QUIC | `kcp`, `quic` | ❌ | |

Jeder unterstützte Transport funktioniert mit UDP. Potatso importiert keinen Server, dessen Transport es nicht unterstützt.

WebSocket Early Data sendet die ersten Bytes einer Verbindung mit dem WebSocket-Handshake mit und spart so einen Round-Trip. Sie wird durch `?ed=2048` am Ende des Link-Pfads oder durch `max-early-data` in einem Clash-Abonnement festgelegt.

Xray bietet HTTP/2 nicht mehr an: Xray-Server, die es nutzten, verwenden jetzt XHTTP, das Potatso noch nicht unterstützt.

## TLS {#tls}

| Einstellung | Clash-Schlüssel | Link-Feld | Unterstützt |
| --- | --- | --- | --- |
| Servername (SNI) | `servername` | `sni` | ✅ Ohne Angabe verwendet Potatso die Adresse des Servers. |
| ALPN | `alpn` | `alpn` | ✅ Ohne Angabe sendet Potatso `http/1.1` für WebSocket und `h2` für gRPC und HTTP/2. |
| Zertifikatsprüfung überspringen | `skip-cert-verify` | `allowInsecure` | ✅ |
| Browser-Fingerabdruck | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` und `random`. Andere Namen verbinden mit einem Standard-Handshake. |
| Zertifikat-Pinning | `fingerprint` | `pcs` | ❌ |
| REALITY | `reality-opts` | `security=reality` | ❌ |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ❌ |
| Eigenes CA-Zertifikat | | | ❌ |

Schaltest du die Zertifikatsprüfung aus, kann jeder zwischen dir und dem Server deinen Datenverkehr mitlesen. Potatso verbindet nicht mit einem VMess-Server, der REALITY, ECH oder einen Zertifikat-Pin braucht, weil eine Verbindung ohne sie nicht den Schutz böte, den der Server verlangt. Nutze für REALITY VLESS oder Trojan.

Ein Browser-Fingerabdruck lässt den TLS-Handshake der Verbindung wie den dieses Browsers aussehen. Er ändert nicht, was der Server unterstützen muss.

## UDP {#udp}

UDP ist bei VMess-Servern standardmäßig aus. Schalte **UDP-Relay** in den Servereinstellungen ein oder setze `udp: true` in einem Clash-Abonnement.

Potatso sendet jeden UDP-Flow über eine eigene VMess-Verbindung, was jeder VMess-Server akzeptiert. Es unterstützt die Kodierungen XUDP und PacketAddr nicht (`packetEncoding` in einem Link, `packet-encoding` oder `xudp` in einem Clash-Abonnement), die viele UDP-Flows über eine Verbindung tragen: Ein damit eingerichteter Server funktioniert trotzdem, und Potatso weist beim Import darauf hin, dass es stattdessen sein eigenes UDP nutzt. Apps, die Full-Cone-NAT brauchen, etwa manche Spiele, funktionieren damit eventuell nicht.

Bei eingeschaltetem [Multiplexing](#mux) läuft UDP stattdessen über die gemeinsame Verbindung.

## Multiplexing {#mux}

Potatso kann mehrere Verbindungen über eine VMess-Verbindung führen, in einem Clash-Abonnement über `smux` festgelegt:

| Protokoll | `smux`-`protocol` | Server |
| --- | --- | --- |
| Mux.Cool | `muxcool` | Xray, V2Ray und sing-box, ohne Servereinstellung |
| sing-mux | `h2mux`, `smux`, `yamux` | sing-box mit eingeschaltetem Multiplexing |

TCP und UDP funktionieren beide. Mux.Cool schließt beide Richtungen einer Verbindung gemeinsam, daher sollte eine App, die das Senden beendet und dann auf die Antwort wartet, einen Server ohne Multiplexing nutzen.

## Anfrageoptionen {#request-options}

Ein VMess-Client wählt für jede Verbindung einige Optionen, und jeder Server akzeptiert jede davon. Potatso sendet seinen Datenverkehr immer in verschlüsselten Chunks und markiert das Ende jedes Uploads; die anderen setzt es nicht:

| Option | Clash-Schlüssel | Potatso |
| --- | --- | --- |
| Chunk-Stream | | Immer an |
| Chunk-Maskierung | | Aus |
| Globales Padding | `global-padding` | Aus. Potatso warnt, wenn du einen Server importierst, der es setzt. |
| Authentifizierte Länge | `authenticated-length` | Aus. Potatso warnt, wenn du einen Server importierst, der sie setzt. |

Chunk-Maskierung und globales Padding verbergen die Größe jedes Chunks vor Beobachtern. Ohne sie bleibt dein Datenverkehr weiterhin unlesbar, sein Muster ist aber leichter zu erkennen.

### Große Uploads {#large-uploads}

Eine einzelne VMess-Verbindung kann etwa 1 GiB hochladen. VMess nummeriert seine verschlüsselten Chunks mit einem Zähler, der danach ausläuft, und ein Weitermachen würde die Verschlüsselung schwächen, daher schließt Potatso stattdessen die Verbindung. Downloads haben kein Limit. Nutze für Uploads von mehr als 1 GiB in einer Verbindung einen VLESS- oder Trojan-Server.

## Funktionsunterstützung {#features}

| Funktion | Unterstützt |
| --- | --- |
| [AEAD-Authentifizierung](https://www.v2fly.org/en_US/developer/protocols/vmess.html) (`alterId` 0) | ✅ |
| Alte MD5-Authentifizierung (`alterId` über 0) | ❌ Server mit `alterId` über 0 akzeptieren die AEAD-Authentifizierung. |
| Verschlüsselungen `aes-128-gcm`, `chacha20-poly1305`, `none`, `auto` | ✅ |
| Verschlüsselungen `zero` und das veraltete `aes-128-cfb` | ❌ |
| Chunk-Stream, Ende-des-Uploads-Markierung | ✅ |
| Chunk-Maskierung, globales Padding, authentifizierte Länge | ❌ Server akzeptieren Verbindungen ohne sie |
| UDP | ✅ Eine Verbindung pro Flow |
| Uploads über etwa 1 GiB auf einer Verbindung | ❌ Siehe [Große Uploads](#large-uploads) |
| XUDP, PacketAddr | ❌ |
| Mux.Cool | ✅ TCP und UDP |
| sing-mux (h2mux, smux, yamux) | ✅ TCP und UDP |
| Transporte | Siehe [Transporte](#transports) |
| TLS | Siehe [TLS](#tls) |
| [v2rayN-Share-Links](#links) (Version 2) | ✅ |
| [Xray-Share-Links](https://github.com/XTLS/Xray-core/discussions/716) | ✅ |
| Shadowrocket-Share-Links | Nur Import |

## `vmess://`-Links {#links}

Ein `vmess://`-Link enthält einen ganzen Server in einer Zeile. Potatso importiert drei Formen und teilt die ersten beiden.

Die v2rayN-Form, die häufigste, ist ein Base64-kodiertes JSON-Objekt:

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

| Feld | Beschreibung |
| --- | --- |
| `v` | Formatversion, `2`. |
| `ps` | Optional. Der Name des Servers in Potatso. |
| `add` | Serveradresse. |
| `port` | Serverport. |
| `id` | Die UUID. |
| `aid` | `alterId`. Siehe [alterId](#alterid). |
| `scy` | Die [Verschlüsselung](#ciphers). Ohne Angabe `auto`. |
| `net` | Der [Transport](#transports): `tcp`, `ws`, `grpc`, `h2` oder `httpupgrade`. |
| `type` | `none` oder `http` für einen TCP-HTTP-Header, den Potatso nicht unterstützt. |
| `host` | Der `Host`-Header für WebSocket, HTTP/2 und HTTP Upgrade. |
| `path` | Der Pfad für WebSocket, HTTP/2 und HTTP Upgrade oder der Dienstname für gRPC. Ein WebSocket-Pfad kann für Early Data auf `?ed=2048` enden. |
| `tls` | `tls`, um TLS zu nutzen, oder leer. |
| `sni`, `alpn`, `fp` | Der [TLS](#tls)-Servername, die ALPN-Liste und der Browser-Fingerabdruck. |

Die Xray-Form ist eine URL, mit der Verschlüsselung in `encryption` und den Transport- und TLS-Einstellungen als Abfrageparametern:

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

| Parameter | Beschreibung |
| --- | --- |
| `type` | Der [Transport](#transports). |
| `encryption` | Die [Verschlüsselung](#ciphers). Ohne Angabe `auto`. |
| `security` | `tls` oder `none`. |
| `sni`, `alpn`, `fp` | Der [TLS](#tls)-Servername, die ALPN-Liste und der Browser-Fingerabdruck. |
| `host`, `path` | Der `Host`-Header und der Pfad, wie in der v2rayN-Form. |
| `serviceName` | Der gRPC-Dienstname. |
| `ed` | WebSocket Early Data, in Byte. |

Potatso importiert auch die Form von Shadowrocket, `vmess://base64(cipher:uuid@host:port)?remarks=…&obfs=websocket&…`.

### Beispiele {#link-examples}

Jedes Beispiel zeigt den Link zum Importieren. Die UUID ist `b831381d-6324-4d53-ad4f-8cda48b30811`.

WebSocket mit TLS und Early Data, über `cdn.example.com`, mit dem Chrome-Fingerabdruck:

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

gRPC mit TLS und `aes-128-gcm`, Dienstname `vmess-grpc`:

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

Einfaches TCP mit `chacha20-poly1305`, in der Xray-Form:

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

HTTP Upgrade mit TLS, in der Xray-Form:

```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 einem Clash-Abonnement {#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/de/protocols/vmess/index.mdx