---
title: "VMess"
description: "As cifras, transportes, links e recursos do VMess que o Potatso suporta."
---

> 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

Um servidor VMess é descrito por um **UUID**, uma **cifra** que criptografa o tráfego e um **transporte** que carrega a conexão, como WebSocket ou gRPC, com ou sem TLS. O Potatso conecta a um servidor quando suporta a cifra, o transporte e os ajustes de TLS dele. Use as tabelas abaixo para conferir os ajustes do seu servidor, como mostrados pelo seu provedor ou no link `vmess://` dele.

Você pode adicionar um servidor VMess à mão, com um [link `vmess://`](#links), ou importando:

- uma assinatura Clash ou Mihomo,
- uma configuração do Xray ou do V2Ray,
- uma configuração do Surge.

O Potatso ainda não importa servidores VMess de uma configuração do sing-box. Use o link `vmess://` do servidor.

## Cifras {#ciphers}

| Cifra | Suportada |
| --- | --- |
| `auto` | ✅ O Potatso escolhe `aes-128-gcm`, que todo dispositivo Apple executa em hardware. |
| `aes-128-gcm` | ✅ |
| `chacha20-poly1305` | ✅ |
| `none` | ✅ |
| `zero` | ❌ |
| `aes-128-cfb` (legado) | ❌ |

`none` e `zero` enviam seu tráfego sem criptografia. Use `none` somente com TLS, que então criptografa a conexão. O Potatso não conecta com `zero`, que também elimina a proteção contra adulteração: escolha outra cifra no seu servidor.

### alterId {#alterid}

O Potatso sempre usa a autenticação atual do VMess, que equivale a `alterId` 0. Os servidores cujo usuário ainda tem um `alterId` acima de 0 também a aceitam, então você pode deixar o servidor como está. O Potatso não suporta a autenticação antiga que só o `alterId` acima de 0 usava, que os servidores descontinuaram desde 2022.

## Transportes {#transports}

| Transporte | `net` / `type` do link | Suportado | Testado com |
| --- | --- | --- | --- |
| Nenhum (TCP puro) | `tcp`, ou nenhum | ✅ Com ou sem TLS | Xray, sing-box, V2Ray |
| WebSocket | `ws` | ✅ Com ou sem TLS e early data | Xray, sing-box, V2Ray |
| gRPC | `grpc` | ✅ Com ou sem TLS | Xray, sing-box, V2Ray |
| HTTP/2 | `h2` ou `http` | ✅ Com TLS | sing-box, V2Ray |
| HTTP Upgrade | `httpupgrade` | ✅ Com ou sem TLS | Xray, sing-box |
| TCP com cabeçalho HTTP | `tcp` com `type=http` | ❌ | |
| XHTTP | `xhttp` | ❌ | |
| mKCP, QUIC | `kcp`, `quic` | ❌ | |

Todo transporte suportado funciona com UDP. O Potatso não importa um servidor cujo transporte ele não suporta.

O early data do WebSocket envia os primeiros bytes de uma conexão junto com o handshake do WebSocket, economizando uma ida e volta. Ele é definido por `?ed=2048` no fim do caminho do link, ou por `max-early-data` em uma assinatura Clash.

O Xray não oferece mais HTTP/2: os servidores Xray que o usavam agora usam XHTTP, que o Potatso ainda não suporta.

## TLS {#tls}

| Ajuste | Chave do Clash | Campo do link | Suportado |
| --- | --- | --- | --- |
| Nome do servidor (SNI) | `servername` | `sni` | ✅ Sem um, o Potatso usa o endereço do servidor. |
| ALPN | `alpn` | `alpn` | ✅ Sem um, o Potatso envia `http/1.1` para WebSocket e `h2` para gRPC e HTTP/2. |
| Ignorar a verificação de certificado | `skip-cert-verify` | `allowInsecure` | ✅ |
| Impressão digital do navegador | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` e `random`. Outros nomes conectam com um handshake padrão. |
| Fixação de certificado | `fingerprint` | `pcs` | ❌ |
| REALITY | `reality-opts` | `security=reality` | ❌ |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ❌ |
| Certificado CA personalizado | | | ❌ |

Desativar a verificação de certificado permite que qualquer pessoa entre você e o servidor leia o seu tráfego. O Potatso não conecta a um servidor VMess que precise de REALITY, ECH ou fixação de certificado, porque conectar sem eles não daria a proteção que o servidor exige. Use VLESS ou Trojan para REALITY.

Uma impressão digital de navegador faz o handshake TLS da conexão parecer o daquele navegador. Ela não muda o que o servidor precisa suportar.

## UDP {#udp}

O UDP vem desativado por padrão nos servidores VMess. Ative o **Relay UDP** nos ajustes do servidor, ou defina `udp: true` em uma assinatura Clash.

O Potatso envia cada fluxo UDP por uma conexão VMess própria, o que todo servidor VMess aceita. Ele não suporta as codificações XUDP e PacketAddr (`packetEncoding` em um link, `packet-encoding` ou `xudp` em uma assinatura Clash), que transportam muitos fluxos UDP por uma única conexão: um servidor configurado com elas continua funcionando, e o Potatso avisa na importação que usa o próprio UDP. Apps que precisam de NAT full-cone, como alguns jogos, podem não funcionar com isso.

Com a [multiplexação](#mux) ativada, o UDP viaja pela conexão compartilhada.

## Multiplexação {#mux}

O Potatso pode executar várias conexões sobre uma única conexão VMess, definida com `smux` em uma assinatura Clash:

| Protocolo | `protocol` de `smux` | Servidores |
| --- | --- | --- |
| Mux.Cool | `muxcool` | Xray, V2Ray e sing-box, sem ajuste no servidor |
| sing-mux | `h2mux`, `smux`, `yamux` | sing-box com a multiplexação ativada |

TCP e UDP funcionam. O Mux.Cool fecha os dois sentidos de uma conexão juntos, então um app que para de enviar e depois espera a resposta deve usar um servidor sem multiplexação.

## Opções de requisição {#request-options}

Um cliente VMess escolhe algumas opções para cada conexão, e todo servidor aceita qualquer uma delas. O Potatso sempre envia seu tráfego em blocos criptografados e marca o fim de cada upload, e não define as outras:

| Opção | Chave do Clash | Potatso |
| --- | --- | --- |
| Fluxo em blocos | | Sempre ativado |
| Mascaramento de blocos | | Desativado |
| Padding global | `global-padding` | Desativado. O Potatso avisa quando você importa um servidor que o define. |
| Comprimento autenticado | `authenticated-length` | Desativado. O Potatso avisa quando você importa um servidor que o define. |

O mascaramento de blocos e o padding global escondem de quem observa o tamanho de cada bloco. Sem eles, seu tráfego continua ilegível, mas o padrão dele é mais fácil de reconhecer.

### Uploads grandes {#large-uploads}

Uma única conexão VMess pode enviar cerca de 1 GiB. O VMess numera seus blocos criptografados com um contador que se esgota depois disso, e continuar enfraqueceria a criptografia, então o Potatso fecha a conexão. Os downloads não têm limite. Para uploads maiores que 1 GiB em uma única conexão, use um servidor VLESS ou Trojan.

## Suporte a recursos {#features}

| Recurso | Suportado |
| --- | --- |
| [Autenticação AEAD](https://www.v2fly.org/en_US/developer/protocols/vmess.html) (`alterId` 0) | ✅ |
| Autenticação MD5 legada (`alterId` acima de 0) | ❌ Os servidores com `alterId` acima de 0 aceitam a autenticação AEAD. |
| Cifras `aes-128-gcm`, `chacha20-poly1305`, `none`, `auto` | ✅ |
| Cifras `zero` e a legada `aes-128-cfb` | ❌ |
| Fluxo em blocos, marcador de fim de upload | ✅ |
| Mascaramento de blocos, padding global, comprimento autenticado | ❌ Os servidores aceitam conexões sem eles |
| UDP | ✅ Uma conexão por fluxo |
| Uploads acima de cerca de 1 GiB em uma conexão | ❌ Veja [Uploads grandes](#large-uploads) |
| XUDP, PacketAddr | ❌ |
| Mux.Cool | ✅ TCP e UDP |
| sing-mux (h2mux, smux, yamux) | ✅ TCP e UDP |
| Transportes | Veja [Transportes](#transports) |
| TLS | Veja [TLS](#tls) |
| [Links de compartilhamento do v2rayN](#links) (versão 2) | ✅ |
| [Links de compartilhamento do Xray](https://github.com/XTLS/Xray-core/discussions/716) | ✅ |
| Links de compartilhamento do Shadowrocket | Somente importação |

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

Um link `vmess://` guarda um servidor inteiro em uma linha. O Potatso importa três formas e compartilha as duas primeiras.

A forma do v2rayN, a mais comum, é um objeto JSON codificado em Base64:

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

| Campo | Descrição |
| --- | --- |
| `v` | Versão do formato, `2`. |
| `ps` | Opcional. O nome do servidor no Potatso. |
| `add` | Endereço do servidor. |
| `port` | Porta do servidor. |
| `id` | O UUID. |
| `aid` | `alterId`. Veja [alterId](#alterid). |
| `scy` | A [cifra](#ciphers). Sem uma, `auto`. |
| `net` | O [transporte](#transports): `tcp`, `ws`, `grpc`, `h2` ou `httpupgrade`. |
| `type` | `none`, ou `http` para um cabeçalho HTTP no TCP, que o Potatso não suporta. |
| `host` | O cabeçalho `Host` para WebSocket, HTTP/2 e HTTP Upgrade. |
| `path` | O caminho para WebSocket, HTTP/2 e HTTP Upgrade, ou o nome do serviço para gRPC. Um caminho WebSocket pode terminar com `?ed=2048` para early data. |
| `tls` | `tls` para usar TLS, ou vazio. |
| `sni`, `alpn`, `fp` | O nome do servidor [TLS](#tls), a lista de ALPN e a impressão digital do navegador. |

A forma do Xray é uma URL, com a cifra em `encryption` e o transporte e os ajustes de TLS como parâmetros de consulta:

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

| Parâmetro | Descrição |
| --- | --- |
| `type` | O [transporte](#transports). |
| `encryption` | A [cifra](#ciphers). Sem uma, `auto`. |
| `security` | `tls`, ou `none`. |
| `sni`, `alpn`, `fp` | O nome do servidor [TLS](#tls), a lista de ALPN e a impressão digital do navegador. |
| `host`, `path` | O cabeçalho `Host` e o caminho, como na forma do v2rayN. |
| `serviceName` | O nome do serviço gRPC. |
| `ed` | Early data do WebSocket, em bytes. |

O Potatso também importa a forma do Shadowrocket, `vmess://base64(cipher:uuid@host:port)?remarks=…&obfs=websocket&…`.

### Exemplos {#link-examples}

Cada exemplo mostra o link a importar. O UUID é `b831381d-6324-4d53-ad4f-8cda48b30811`.

WebSocket com TLS e early data, por `cdn.example.com`, com a impressão digital do Chrome:

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

gRPC com TLS e `aes-128-gcm`, nome de serviço `vmess-grpc`:

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

TCP puro com `chacha20-poly1305`, na forma do Xray:

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

HTTP Upgrade com TLS, na forma do 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
```

### Em uma assinatura 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/pt-br/protocols/vmess/index.mdx