## Porquê OpenVPN?

OpenVPN era o padrão de facto para VPNs de código aberto quando este script foi criado. WireGuard surgiu depois e é mais simples e rápido para a maioria dos casos de uso. Consulte [wireguard-install](https://github.com/angristan/wireguard-install).

Dito isto, o OpenVPN ainda faz sentido quando precisas de:

- **Suporte TCP**: funciona em ambientes restritivos onde o UDP está bloqueado (redes corporativas, aeroportos, hotéis, etc.)
- **Chaves privadas protegidas por palavra-passe**: as configurações do WireGuard armazenam a chave privada em texto simples
- **Compatibilidade legada**: existem clientes para praticamente todas as plataformas, incluindo sistemas mais antigos

## Funcionalidades

- Instala e configura um servidor OpenVPN pronto a usar
- Interface CLI para automação e scripting (modo não interativo com saída JSON)
- Renovação de certificados tanto para clientes como para servidor
- Listar e monitorizar clientes ligados
- Desconexão imediata do cliente ao revogar certificado (através da interface de gestão)
- Utiliza [repositórios oficiais do OpenVPN](https://community.openvpn.net/openvpn/wiki/OpenvpnSoftwareRepos) quando possível para as versões estáveis mais recentes
- Regras de firewall e encaminhamento geridas de forma transparente (suporte nativo para firewalld e nftables, recurso ao iptables)
- Sub-redes VPN configuráveis (IPv4: predefinido `10.8.0.0/24`, IPv6: predefinido `fd42:42:42:42::/112`)
- MTU do túnel configurável (predefinido: `1500`)
- Se necessário, o script pode remover limpidamente o OpenVPN, incluindo configuração e regras de firewall
- Definições de encriptação personalizáveis, definições predefinidas melhoradas (consulte [Segurança e Encriptação](#security-and-encryption) abaixo)
- Utiliza as funcionalidades mais recentes do OpenVPN quando disponíveis (consulte [Segurança e Encriptação](#security-and-encryption) abaixo)
- Variedade de resolvedores DNS a serem enviados para os clientes
- Opção de usar um resolvedor auto-hospedado com Unbound (suporta instalações Unbound já existentes)
- Escolha entre TCP e UDP
- Suporte flexível para IPv4/IPv6:
  - Ponto de extremidade do servidor IPv4 ou IPv6 (como os clientes se ligam)
  - Clientes apenas IPv4, apenas IPv6 ou pilha dupla (endereçamento VPN e acesso à Internet)
  - Todas as combinações suportadas: 4→4, 4→4/6, 4→6, 6→4, 6→6, 6→4/6
  - Prevenção automática de fugas: bloqueia o protocolo indesejado em modos de pilha única
- Modo não privilegiado: executar como `nobody`/`nogroup`
- Bloquear fugas DNS no Windows 10
- Nome do certificado do servidor aleatório
- Opção de proteger clientes com uma palavra-passe (encriptação da chave privada)
- Opção para permitir que vários dispositivos usem o mesmo perfil de cliente simultaneamente (desativa endereços IP persistentes)
- **Autenticação por impressão digital do par** (OpenVPN 2.6+): Autenticação simplificada ao estilo WireGuard sem uma AC
- Muitas outras pequenas coisas!

## Compatibilidade

O script suporta estas distribuições Linux:

|                     | Suporte |
| ------------------- | ------- |
| AlmaLinux >= 8      | ✅ 🤖   |
| Amazon Linux 2023   | ✅ 🤖   |
| Arch Linux          | ✅ 🤖   |
| CentOS Stream >= 8  | ✅ 🤖   |
| Debian >= 11        | ✅ 🤖   |
| Fedora >= 40        | ✅ 🤖   |
| openSUSE Leap >= 16 | ✅ 🤖   |
| openSUSE Tumbleweed | ✅ 🤖   |
| Oracle Linux >= 8   | ✅ 🤖   |
| Rocky Linux >= 8    | ✅ 🤖   |
| Ubuntu >= 18.04     | ✅ 🤖   |

A notar:

- O script é testado regularmente apenas nas distribuições marcadas com 🤖.
  - É testado apenas na arquitetura `amd64`.
- O script requer `systemd`.

### Fornecedores recomendados

- [Vultr](https://umami.stanislas.cloud/q/1HH9Thp8i): Localizações mundiais, suporte IPv6, a partir de $2.5/mês
- [Hetzner](https://umami.stanislas.cloud/q/HdzaOJWq7): Localizações mundiais, IPv6, 20 TB de tráfego, a partir de €3.59/mês
- [Digital Ocean](https://umami.stanislas.cloud/q/sEVh1l79B): Localizações mundiais, suporte IPv6, a partir de $4/mês

## Utilização

Primeiro, descarrega o script no teu servidor e torna-o executável:```bash
curl -O https://raw.githubusercontent.com/angristan/openvpn-install/master/openvpn-install.sh
chmod +x openvpn-install.sh

Isso guiará você pela instalação e gerenciamento de clientes.

No seu diretório home, você terá arquivos `.ovpn`. Estes são os arquivos de configuração do cliente. Baixe-os do seu servidor (usando `scp`, por exemplo) e conecte-se usando seu cliente OpenVPN favorito.

Se você tiver alguma dúvida, consulte primeiro o [FAQ](#faq). E se precisar de ajuda, você pode abrir uma [discussão](https://github.com/angristan/openvpn-install/discussions). Por favor, pesquise nas issues e discussões existentes primeiro.

### Modo CLI

> [!WARNING]
> A compatibilidade da API não é garantida. Mudanças que quebram a compatibilidade podem ocorrer entre versões. Se você usar este script programaticamente (por exemplo, em automação ou CI/CD), fixe-se em um commit específico em vez de usar o branch master.

Para automação e scripting, use a interface CLI:```bash
# Install with defaults
./openvpn-install.sh install

# Add a client
./openvpn-install.sh client add alice

# List clients
./openvpn-install.sh client list

# Revoke a client (immediately disconnects if connected)
./openvpn-install.sh client revoke alice

Execute `./openvpn-install.sh <comando> --help` para opções específicas do comando.

#### Gerenciamento de Clientes```bash
# Add a new client
./openvpn-install.sh client add alice

# Add a password-protected client
./openvpn-install.sh client add bob --password

# Revoke a client
./openvpn-install.sh client revoke alice

# Renew a client certificate
./openvpn-install.sh client renew bob --cert-days 365

Saída JSON para scripting:```text
$ ./openvpn-install.sh client list --format json | jq
{
  "clients": [
    {
      "name": "alice",
      "status": "valid",
      "expiry": "2035-01-15",
      "days_remaining": 3650
    },
    {
      "name": "bob",
      "status": "valid",
      "expiry": "2035-01-15",
      "days_remaining": 3650
    },
    {
      "name": "charlie",
      "status": "revoked",
      "expiry": "2035-01-15",
      "days_remaining": null
    }
  ]
}

Mostrar clientes conectados (os dados são atualizados a cada 60 segundos):```text
$ ./openvpn-install.sh server status
══ Connected Clients ══
[INFO] Found 2 connected client(s)

   Name    Real Address          VPN IP      Connected Since   Transfer
   ----    ------------          ------      ---------------   --------
   alice   203.0.113.45:52341    10.8.0.2    2025-01-15 14:32  ↓1.2M ↑500K
   bob     198.51.100.22:41892   10.8.0.3    2025-01-15 09:15  ↓800K ↑200K

[INFO] Note: Data refreshes every 60 seconds.

**Opções de Rede:**

- `--endpoint <host>` - IP público ou hostname para clientes (padrão: detecção automática)
- `--endpoint-type <4|6>` - Versão do IP do endpoint (padrão: `4`)
- `--ip <addr>` - IP de escuta do servidor (padrão: detecção automática)
- `--client-ipv4` - Ativar IPv4 para clientes VPN (padrão: ativado)
- `--no-client-ipv4` - Desativar IPv4 para clientes VPN
- `--client-ipv6` - Ativar IPv6 para clientes VPN (padrão: desativado)
- `--no-client-ipv6` - Desativar IPv6 para clientes VPN
- `--subnet-ipv4 <x.x.x.0>` - Sub-rede IPv4 da VPN (padrão: `10.8.0.0`)
- `--subnet-ipv6 <prefix>` - Sub-rede IPv6 da VPN (padrão: `fd42:42:42:42::`)
- `--port <num>` - Porta do OpenVPN (padrão: `1194`)
- `--port-random` - Usar porta aleatória (49152-65535)
- `--protocol <udp|tcp>` - Protocolo (padrão: `udp`)
- `--mtu <size>` - MTU do túnel (padrão: `1500`)

**Opções de DNS:**

- `--dns <provider>` - Provedor DNS (padrão: `cloudflare`). Opções: `system`, `unbound`, `cloudflare`, `quad9`, `quad9-uncensored`, `fdn`, `dnswatch`, `opendns`, `google`, `yandex`, `adguard`, `nextdns`, `custom`
- `--dns-primary <ip>` - DNS primário personalizado (requer `--dns custom`)
- `--dns-secondary <ip>` - DNS secundário personalizado (requer `--dns custom`)

**Opções de Segurança:**

- `--cipher <cipher>` - Cifra de dados (padrão: `AES-128-GCM`). Opções: `AES-128-GCM`, `AES-192-GCM`, `AES-256-GCM`, `AES-128-CBC`, `AES-192-CBC`, `AES-256-CBC`, `CHACHA20-POLY1305`
- `--cert-type <ecdsa|rsa>` - Tipo de certificado (padrão: `ecdsa`)
- `--cert-curve <curve>` - Curva ECDSA (padrão: `prime256v1`). Opções: `prime256v1`, `secp384r1`, `secp521r1`
- `--rsa-bits <2048|3072|4096>` - Tamanho da chave RSA (padrão: `2048`)
- `--hmac <alg>` - Algoritmo HMAC (padrão: `SHA256`). Opções: `SHA256`, `SHA384`, `SHA512`
- `--tls-sig <mode>` - Modo TLS (padrão: `crypt-v2`). Opções: `crypt-v2`, `crypt`, `auth`
- `--auth-mode <mode>` - Modo de autenticação (padrão: `pki`). Opções: `pki` (baseado em CA), `fingerprint` (impressão digital do peer, requer OpenVPN 2.6+)
- `--tls-version-min <1.2|1.3>` - Versão mínima do TLS (padrão: `1.2`)
- `--tls-ciphersuites <list>` - Suites de cifras TLS 1.3, separadas por dois pontos (padrão: `TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:TLS_CHACHA20_POLY1305_SHA256`)
- `--tls-groups <list>` - Grupos de troca de chaves, separados por dois pontos (padrão: `X25519:prime256v1:secp384r1:secp521r1`)
- `--server-cert-days <n>` - Validade do certificado do servidor em dias (padrão: `3650`)

**Opções de Cliente:**

- `--client <name>` - Nome inicial do cliente (padrão: `client`)
- `--client-password [pass]` - Proteger chave do cliente com senha (padrão: sem senha)
- `--client-cert-days <n>` - Validade do certificado do cliente em dias (padrão: `3650`)
- `--no-client` - Ignorar criação inicial do cliente

**Outras Opções:**

- `--multi-client` - Permitir mesmo certificado em múltiplos dispositivos (padrão: desativado)

#### Exemplos de Automação

**Criação em lote de clientes:**```bash
#!/bin/bash
for user in alice bob charlie; do
  ./openvpn-install.sh client add "$user"
done

**Saída JSON para scripting:**```bash
# Get client list as JSON
./openvpn-install.sh client list --format json | jq '.clients[] | select(.status == "valid")'

# Get connected clients as JSON
./openvpn-install.sh server status --format json

Benefícios:

- Configuração mais simples: Nenhuma infraestrutura de CA necessária
- Mais fácil de entender: Semelhante ao modelo `known_hosts` do SSH
- Ideal para configurações pequenas: Redes domésticas, laboratórios, pequenas equipes

Como funciona:

1. O servidor gera um certificado autoassinado e armazena sua impressão digital
2. Cada cliente gera um certificado autoassinado
3. As impressões digitais dos clientes são adicionadas ao bloco `<peer-fingerprint>` do servidor
4. Os clientes verificam o servidor usando a impressão digital do servidor
5. A revogação remove a impressão digital da configuração do servidor (sem necessidade de CRL)

Compromisso: Revogar um cliente requer recarregar o OpenVPN (as impressões digitais estão no server.conf). No modo PKI, o arquivo CRL é relido automaticamente em novas conexões.

### Canal de dados

> [!NOTA]
> O cifrador padrão do canal de dados mudou no OpenVPN 2.5. Versões anteriores usavam `BF-CBC` como padrão, enquanto o OpenVPN 2.5+ usa `AES-256-GCM:AES-128-GCM`. O OpenVPN 2.6+ também inclui `CHACHA20-POLY1305` na lista de cifradores padrão quando disponível.

Por padrão, o OpenVPN 2.4 e anteriores usavam `BF-CBC` como cifra do canal de dados. Blowfish é um algoritmo antigo (1993) e fraco. Até a documentação oficial do OpenVPN admite isso.

> O padrão é BF-CBC, uma abreviação para Blowfish no modo Cipher Block Chaining.
>
> Usar BF-CBC não é mais recomendado, devido ao seu tamanho de bloco de 64 bits. Esse tamanho pequeno permite ataques baseados em colisões, conforme demonstrado pelo SWEET32. Veja <https://community.openvpn.net/openvpn/wiki/SWEET32> para detalhes.
> Pesquisadores de segurança do INRIA publicaram um ataque a cifras de bloco de 64 bits, como 3DES e Blowfish. Eles mostram que são capazes de recuperar texto claro quando os mesmos dados são enviados com frequência suficiente, e mostram como podem usar vulnerabilidades de cross-site scripting para enviar dados de interesse com frequência suficiente. Isso funciona sobre HTTPS, mas também funciona para HTTP sobre OpenVPN. Veja <https://sweet32.info/> para uma explicação muito melhor e mais elaborada.
>
> O cifrador padrão do OpenVPN, BF-CBC, é afetado por este ataque.

De fato, o AES é o padrão atual. É o cifrador mais rápido e seguro disponível hoje. [SEED](https://en.wikipedia.org/wiki/SEED) e [Camellia](https://github.com/angristan/openvpn-install/blob/master/%3Chttps%3A/en.wikipedia.org/wiki/Camellia_%28cipher)>) não são vulneráveis até agora, mas são mais lentos que o AES e relativamente menos confiáveis.

> Dos cifradores atualmente suportados, o OpenVPN recomenda o uso de AES-256-CBC ou AES-128-CBC. OpenVPN 2.4 e posteriores também suportam GCM. Para 2.4+, recomendamos usar AES-256-GCM ou AES-128-GCM.

AES-256 é 40% mais lento que AES-128, e não há nenhuma razão real para usar uma chave de 256 bits em vez de uma chave de 128 bits com AES. (Fonte: [1](http://security.stackexchange.com/questions/14068/why-most-people-use-256-bit-encryption-instead-of-128-bit),[2](http://security.stackexchange.com/questions/6141/amount-of-simple-operations-that-is-safely-out-of-reach-for-all-humanity/6149#6149)). Além disso, AES-256 é mais vulnerável a [ataques de temporização](https://en.wikipedia.org/wiki/Timing_attack).

AES-GCM é uma [cifra AEAD](https://en.wikipedia.org/wiki/Authenticated_encryption) que significa que ela fornece simultaneamente garantias de confidencialidade, integridade e autenticidade sobre os dados.

ChaCha20-Poly1305 é outra cifra AEAD que oferece segurança semelhante ao AES-GCM. É particularmente útil em dispositivos sem aceleração de hardware AES (AES-NI), como CPUs mais antigas e muitos dispositivos baseados em ARM, onde pode ser significativamente mais rápida que o AES.

O script suporta os seguintes cifradores:

- `AES-128-GCM`
- `AES-192-GCM`
- `AES-256-GCM`
- `AES-128-CBC`
- `AES-192-CBC`
- `AES-256-CBC`
- `CHACHA20-POLY1305` (requer OpenVPN 2.5+)

E usa `AES-128-GCM` como padrão.

OpenVPN 2.4 adicionou um recurso chamado "NCP": _Negociable Crypto Parameters_. Isso significa que você pode fornecer uma suíte de cifras como no HTTPS. Ele é definido como `AES-256-GCM:AES-128-GCM` por padrão e substitui o parâmetro `--cipher` quando usado com um cliente OpenVPN 2.4. Para simplificar, o script define `--cipher` (fallback para clientes não-NCP), `--data-ciphers` (nomenclatura moderna do OpenVPN 2.5+) e `--ncp-ciphers` (alias legado para compatibilidade com OpenVPN 2.4) para a cifra escolhida acima.

### Canal de controle

OpenVPN 2.4 negociará o melhor cifrador disponível por padrão (ex: ECDHE+AES-256-GCM)

#### Cifras TLS 1.2 (`--tls-cipher`)

O script propõe as seguintes opções, dependendo do certificado:

- ECDSA:
  - `TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256`
  - `TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384`
  - `TLS-ECDHE-ECDSA-WITH-CHACHA20-POLY1305-SHA256` (requer OpenVPN 2.5+)
- RSA:
  - `TLS-ECDHE-RSA-WITH-AES-128-GCM-SHA256`
  - `TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384`
  - `TLS-ECDHE-RSA-WITH-CHACHA20-POLY1305-SHA256` (requer OpenVPN 2.5+)

O padrão é `TLS-ECDHE-*-WITH-AES-128-GCM-SHA256`.

#### Cifras TLS 1.3 (`--tls-ciphersuites`)

Quando TLS 1.3 é negociado, um conjunto separado de suítes de cifras é usado. Elas são configuradas através de `--tls-ciphersuites` e usam as convenções de nomenclatura do OpenSSL:

- `TLS_AES_256_GCM_SHA384`
- `TLS_AES_128_GCM_SHA256`
- `TLS_CHACHA20_POLY1305_SHA256`

Por padrão, todas as três suítes de cifras estão habilitadas. As suítes de cifras TLS 1.3 são mais simples porque não incluem o algoritmo de troca de chaves (que é negociado separadamente via key shares).

### Troca de chaves

Historicamente, o OpenVPN usava parâmetros DH de 2048 bits para troca de chaves. Este script costumava oferecer tanto DH (com tamanhos de chave configuráveis) quanto ECDH como alternativas.

OpenVPN 2.4 adicionou suporte a ECDH, e OpenVPN 2.7 tornou `dh none` (ECDH) o padrão, já que o DH de campo finito está sendo depreciado. Como ECDH é agora universalmente suportado e preferido, este script não oferece mais DH tradicional.

O script configura `tls-groups` com a seguinte lista de preferência:```
X25519:prime256v1:secp384r1:secp521r1