🥇Livro "Linux em Ação"

Olá, membros do Habr! No livro, David Clinton descreve 12 projetos reais, incluindo a automação de um sistema de backup e recuperação, a configuração de um serviço de armazenamento pessoal em estilo Dropbox e a criação de seu próprio servidor MediaWiki. Através de exemplos interessantes, você aprenderá sobre virtualização, recuperação de desastres, segurança, backups, implementação de DevOps e solução de problemas do sistema. Cada capítulo termina com um resumo de recomendações práticas, um glossário de novos termos e exercícios.

Trecho "10.1. Criação de um túnel OpenVPN"

Neste livro, já falei bastante sobre criptografia. SSH e SCP podem proteger os dados transmitidos por conexões remotas (capítulo 3), a criptografia de arquivos permite proteger os dados quando armazenados no servidor (capítulo 8), e os certificados TLS/SSL podem proteger os dados durante a transmissão entre sites e navegadores dos clientes (capítulo 9). Mas, às vezes, seus dados precisam de proteção em um espectro mais amplo de conexões. Por exemplo, alguns membros da sua equipe podem ter que trabalhar na estrada, conectando-se à rede via Wi-Fi em pontos de acesso públicos. Definitivamente, não deve-se assumir que todos esses pontos de acesso são seguros, mas sua equipe realmente precisa de uma forma de se conectar aos recursos da empresa — e, nesse caso, uma VPN pode ajudar.

Um túnel VPN bem projetado fornece uma conexão direta entre clientes remotos e o servidor de modo a ocultar os dados durante sua transmissão por uma rede não segura. E daí? Você já viu muitas ferramentas que podem fazer isso usando criptografia. O verdadeiro valor da VPN é que, ao abrir um túnel, você pode conectar redes remotas como se todas fossem locais. De certa forma, você está usando um acesso remoto.

Usando uma rede tão expandida, os administradores podem realizar seu trabalho em seus servidores de qualquer lugar. Mas, mais importante, uma empresa com recursos distribuídos em várias filiais pode torná-los visíveis e acessíveis a todos os grupos que deles necessitam, onde quer que estejam (fig. 10.1).

Um túnel, por si só, não garante segurança. Mas um dos padrões de criptografia pode ser incluído na estrutura da rede, o que aumenta significativamente o nível de segurança. Os túneis criados com o pacote OpenVPN de código aberto utilizam a mesma criptografia TLS/SSL da qual você já leu. O OpenVPN não é a única opção disponível para tunelamento, mas é uma das mais conhecidas. É considerado um pouco mais rápido e seguro do que o protocolo de túnel alternativo de nível 2 que utiliza criptografia IPsec.

Você quer que sua equipe se comunique de forma segura estando em movimento ou trabalhando em prédios diferentes? Para isso, é necessário criar um servidor OpenVPN para permitir o compartilhamento de aplicativos e o acesso ao ambiente de rede local do servidor. Para que isso funcione, basta iniciar duas máquinas virtuais ou dois contêineres: uma para servir como servidor/anfitrião e outra para o cliente. Criar uma VPN não é um processo simples, portanto, provavelmente vale a pena gastar alguns minutos visualizando o quadro geral.

10.1.1. Configurando o Servidor OpenVPN

Antes de começar, aqui vai uma dica útil. Se você for fazer tudo sozinho (e eu recomendo fortemente que faça), provavelmente descobrirá que está trabalhando com várias janelas de terminal abertas na sua área de trabalho, cada uma conectada à sua própria máquina. Há o risco de que, em algum momento, você insira um comando incorretamente em uma das janelas. Para evitar isso, você pode usar o comando hostname para mudar o nome da máquina exibido no prompt de comando para algo que indique claramente onde você está. Assim que fizer isso, será necessário sair do servidor e entrar novamente para que as novas configurações entrem em vigor. Veja como isso fica:

Seguindo essa abordagem e atribuindo nomes apropriados a cada uma das máquinas com as quais você trabalha, você conseguirá rastrear facilmente onde está.

Após usar o hostname, você pode se deparar com mensagens irritantes como Unable to Resolve Host OpenVPN-Server ao executar comandos subsequentes. Atualizar o arquivo /etc/hosts com o novo nome de host apropriado deve resolver o problema.

Preparando seu servidor para o OpenVPN

Para instalar o OpenVPN no seu servidor, você precisa de dois pacotes: openvpn e easy-rsa (para gerenciar o processo de geração da chave de criptografia). Usuários do CentOS devem, se necessário, instalar o repositório epel-release primeiro, como feito no capítulo 2. Para poder verificar o acesso ao aplicativo do servidor, você também pode instalar o servidor web Apache (apache2 para Ubuntu e httpd no CentOS).

Enquanto você configura o servidor, recomendo ativar o firewall, que bloqueia todas as portas, exceto 22 (SSH) e 1194 (porta padrão do OpenVPN). Este exemplo ilustra como o ufw funcionará no Ubuntu, mas tenho certeza de que você ainda se lembra do programa firewalld do CentOS do capítulo 9:

# ufw enable
# ufw allow 22
# ufw allow 1194

Para permitir o roteamento interno entre as interfaces de rede no servidor, você precisa descomentar uma linha (net.ipv4.ip_forward = 1) no arquivo /etc/sysctl.conf. Isso permitirá redirecionar clientes remotos conforme necessário após a conexão. Para que a nova configuração tenha efeito, execute sysctl -p:

# nano /etc/sysctl.conf
# sysctl -p

Agora o ambiente do servidor está completamente configurado, mas ainda há mais uma coisa a fazer antes de você estar pronto: será necessário executar as seguintes etapas (discutiremos isso em detalhes a seguir).

Crie no servidor um conjunto de chaves para a infraestrutura de chave pública (PKI) usando os scripts fornecidos com o pacote easy-rsa. Essencialmente, o servidor OpenVPN também funciona como sua própria autoridade certificadora (AC).
Prepare as chaves apropriadas para o cliente
Configure o arquivo server.conf para o servidor
Configure seu cliente OpenVPN
Verifique seu VPN

Geração de chaves de criptografia

Para simplificar, você pode configurar sua infraestrutura de chaves na mesma máquina onde o servidor OpenVPN está em execução. No entanto, nas recomendações de segurança, geralmente é sugerido usar um servidor AC separado para implantações em ambiente de produção. O processo de geração e distribuição de recursos de chave de criptografia para uso no OpenVPN é ilustrado na Fig. 10.2.

Quando você instalou o OpenVPN, um diretório /etc/openvpn/ foi criado automaticamente, mas ainda não há nada nele. Os pacotes openvpn e easy-rsa vêm com exemplos de arquivos de modelo que você pode usar como base para sua configuração. Para iniciar o processo de certificação, copie o diretório de modelo easy-rsa de /usr/share/ para /etc/openvpn e acesse o diretório easy-rsa/:

# cp -r /usr/share/easy-rsa/ /etc/openvpn
$ cd /etc/openvpn/easy-rsa

O catálogo easy-rsa agora conterá vários scripts. A tabela 10.1 lista as ferramentas que você usará para criar chaves.

As operações listadas exigem permissões de root, portanto, você precisa se tornar root através do sudo su.

O primeiro arquivo com o qual você vai trabalhar é chamado vars e contém variáveis de ambiente que o easy-rsa utiliza ao gerar chaves. Você precisará editar o arquivo para usar seus próprios valores em vez dos valores padrão que já estão lá. Veja como ficará meu arquivo (listagem 10.1).

Listagem 10.1. Principais trechos do arquivo /etc/openvpn/easy-rsa/vars

export KEY_COUNTRY="CA"
export KEY_PROVINCE="ON"
export KEY_CITY="Toronto"
export KEY_ORG="Bootstrap IT"
export KEY_EMAIL="info@bootstrap-it.com"
export KEY_OU="IT"

Executar o arquivo vars permitirá que seus valores sejam passados para o ambiente do shell, onde serão incluídos no conteúdo de suas novas chaves. Por que o comando sudo por si só não funciona? Porque, na primeira etapa, estamos editando o script chamado vars e, em seguida, aplicando-o. Aplicar significa que o arquivo vars passa seus valores para o ambiente do shell, de onde serão incluídos no conteúdo de suas novas chaves.

Certifique-se de executar o arquivo novamente usando um novo shell para concluir o processo não finalizado. Quando isso for feito, o script solicitará que você inicie outro script, clean-all, para remover qualquer conteúdo do diretório /etc/openvpn/easy-rsa/keys/:

Naturalmente, o próximo passo será executar o script clean-all, seguido do build-ca, que utiliza o script pkitool para criar o certificado raiz. Você será solicitado a confirmar as configurações de identificação fornecidas pelo vars:

# ./clean-all
# ./build-ca
Generating a 2048 bit RSA private key

Em seguida, é o script build-key-server. Como ele usa o mesmo script pkitool junto com o novo certificado raiz, você verá as mesmas perguntas para confirmar a criação do par de chaves. As chaves serão nomeadas com base nos argumentos que você fornece, que, a menos que você esteja executando várias VPN neste computador, geralmente serão server, como no exemplo:

# ./build-key-server server
[...]
Certificate is to be certified until Aug 15 23:52:34 2027 GMT (3650 days)
Sign the certificate? [y/n]:y
1 out of 1 certificate requests certified, commit? [y/n]y
Write out database with 1 new entries
Data Base Updated

OpenVPN utiliza parâmetros gerados com o algoritmo Diffie-Hellman (com o uso do build-dh) para negociar a autenticação para novas conexões. O arquivo criado aqui não deve ser secreto, mas deve ser gerado usando o script build-dh para as chaves RSA que estão ativas no momento. Se você criar novas chaves RSA no futuro, precisará atualizar o arquivo baseado no algoritmo Diffie-Hellman:

# ./build-dh

Agora suas chaves do lado do servidor irão para o diretório /etc/openvpn/easy-rsa/keys/, mas o OpenVPN não sabe disso. Por padrão, o OpenVPN procurará as chaves em /etc/openvpn/, então copie-as:

# cp /etc/openvpn/easy-rsa/keys/server* /etc/openvpn
# cp /etc/openvpn/easy-rsa/keys/dh2048.pem /etc/openvpn
# cp /etc/openvpn/easy-rsa/keys/ca.crt /etc/openvpn

Preparação das chaves de criptografia do cliente

Como você já viu, na criptografia TLS, pares de chaves correspondentes são usados: uma configurada no servidor e a outra no cliente remoto. Isso significa que você precisará das chaves do cliente. Nosso velho amigo pkitool é exatamente o que precisamos para isso. Neste exemplo, executando o programa no diretório /etc/openvpn/easy-rsa/, passamos o argumento client para gerar os arquivos chamados client.crt e client.key:

# ./pkitool client

Os dois arquivos do cliente, junto com o arquivo original ca.crt, que ainda está no diretório keys/, agora devem ser transferidos com segurança para o seu cliente. Devido à sua propriedade e permissões, isso pode não ser uma tarefa fácil. A abordagem mais simples é copiar manualmente o conteúdo do arquivo original (e nada além desse conteúdo) para um terminal trabalhando na área de trabalho do seu PC (selecione o texto, clique com o botão direito e escolha a opção Copiar). Em seguida, cole isso em um novo arquivo com o mesmo nome que você cria no segundo terminal conectado ao seu cliente.

Mas qualquer um pode cortar e colar. Pense como um administrador, porque você nem sempre terá acesso a uma GUI onde a operação de cortar/colar é possível. Copie os arquivos para o diretório pessoal do seu usuário (para que a operação remota scp possa acessá-los), e então use chown para mudar o proprietário dos arquivos de root para um usuário comum sem direitos de root, para que você possa realizar a ação remota scp. Verifique se todos os seus arquivos estão configurados e acessíveis neste momento. Você os moverá para o cliente um pouco mais tarde:

# cp /etc/openvpn/easy-rsa/keys/client.key /home/ubuntu/
# cp /etc/openvpn/easy-rsa/keys/ca.crt /home/ubuntu/
# cp /etc/openvpn/easy-rsa/keys/client.crt /home/ubuntu/
# chown ubuntu:ubuntu /home/ubuntu/client.key
# chown ubuntu:ubuntu /home/ubuntu/client.crt
# chown ubuntu:ubuntu /home/ubuntu/ca.crt

Com um conjunto completo de chaves de criptografia prontas para uso, você precisa informar ao servidor como deseja configurar a VPN. Isso é feito por meio do arquivo server.conf.

Reduzindo o número de pressionamentos de tecla
Você está digitando demais? A extensão com parênteses ajuda a reduzir esses seis comandos para dois. Estou certo de que você conseguirá estudar esses dois exemplos e entender o que está acontecendo. Mais importante ainda, você conseguirá entender como aplicar esses princípios em operações que envolvem dezenas ou até centenas de elementos:
# cp /etc/openvpn/easy-rsa/keys/{ca.crt,client.{key,crt}} /home/ubuntu/
# chown ubuntu:ubuntu /home/ubuntu/{ca.crt,client.{key,crt}}

Configurando o arquivo server.conf

Como você pode saber como deve ser o arquivo server.conf? Lembre-se do modelo do diretório easy-rsa que você copiou de /usr/share/? Durante a instalação do OpenVPN, ficou um arquivo compactado do modelo de configuração que você pode copiar para /etc/openvpn/. Vou me basear no fato de que o modelo está compactado e apresentá-lo a uma ferramenta útil: zcat.

Você já sabe como exibir o conteúdo de texto de um arquivo na tela usando o comando cat, mas e se o arquivo estiver compactado com gzip? Você sempre pode descompactar o arquivo, e então o cat irá exibi-lo, mas isso requer um ou dois passos a mais do que o necessário. Em vez disso, como você provavelmente já adivinhou, pode usar o comando zcat para carregar o texto descompactado em memória em um único passo. No exemplo a seguir, em vez de imprimir o texto na tela, você o redirecionará para um novo arquivo chamado server.conf:

# zcat 
  /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz 
  > /etc/openvpn/server.conf
$ cd /etc/openvpn

Deixemos de lado a extensa e útil documentação que acompanha o arquivo e vejamos como ele pode parecer quando você terminar de editá-lo. Observe que o ponto e vírgula (;) indica ao OpenVPN para não ler e não executar a próxima linha (listagem 10.2).

Vamos examinar algumas dessas configurações.

Por padrão, o OpenVPN opera através da porta 1194. Você pode alterar isso, por exemplo, para ocultar ainda mais suas ações ou evitar conflitos com outros túneis ativos. Como a porta 1194 requer mínima coordenação com os clientes, é melhor fazer assim.
O OpenVPN utiliza o protocolo de controle de transmissão (TCP) ou o protocolo de datagramas do usuário (UDP) para transmissão de dados. O TCP pode ser um pouco mais lento, mas é mais confiável e tem maior probabilidade de ser compreendido por aplicativos que trabalham em ambas as extremidades do túnel.
Você pode especificar dev tun quando quiser criar um túnel IP mais simples e eficiente que transmite o conteúdo dos dados e nada mais. Por outro lado, se você precisar conectar várias interfaces de rede (e as redes que elas representam), criando uma ponte Ethernet, você terá que escolher dev tap. Se você não entender o que tudo isso significa, use o argumento tun.
As próximas quatro linhas informam ao OpenVPN os nomes de três arquivos de autenticação no servidor e o arquivo de parâmetros dh2048 que você criou anteriormente.
A linha server define o intervalo e a máscara de sub-rede que serão usados para atribuir endereços IP aos clientes quando eles se conectarem.
O parâmetro opcional push "route 10.0.3.0 255.255.255.0" permite que clientes remotos acessem sub-redes privadas atrás do servidor. Para que isso funcione, também é necessário configurar a rede no próprio servidor, para que a sub-rede privada conheça a sub-rede OpenVPN (10.8.0.0).
A linha port-share localhost 80 permite redirecionar o tráfego do cliente que chega pela porta 1194 para o servidor web local, que está escutando na porta 80. (Isso será útil se você planeja envolver um servidor web para testar sua VPN.) Isso funciona apenas quando o protocolo tcp é escolhido.
As linhas user nobody e group nogroup devem estar ativas — para isso, você precisa remover os pontos e vírgulas (;). Fazer com que os clientes remotos sejam executados sob nobody e nogroup garante que as sessões no servidor sejam não privilegiadas.
log indica que os registros atuais no log irão sobrescrever os registros antigos a cada inicialização do OpenVPN, enquanto log-append adiciona novos registros ao arquivo de log existente. O próprio arquivo openvpn.log é gravado no diretório /etc/openvpn/.

Além disso, o valor client-to-client também é frequentemente adicionado ao arquivo de configuração, para que vários clientes possam se ver além do servidor OpenVPN. Se você estiver satisfeito com sua configuração, pode iniciar o servidor OpenVPN:

# systemctl start openvpn

Devido à natureza mutável das relações entre OpenVPN e systemd, para iniciar o serviço, pode ser necessário usar a seguinte sintaxe: systemctl start openvpn@server.

Executar ip addr para exibir a lista de interfaces de rede do seu servidor agora deve retornar uma referência à nova interface nomeada tun0. O OpenVPN irá criá-la para atender os clientes que chegam:

$ ip addr
[...]
4: tun0: mtu 1500 qdisc [...]
      link/none
      inet 10.8.0.1 peer 10.8.0.2/32 scope global tun0
          valid_lft forever preferred_lft forever

Você pode precisar reiniciar o servidor antes que tudo comece a funcionar totalmente. A próxima parada é o computador cliente.

10.1.2. Configuração do Cliente OpenVPN

Tradicionalmente, túneis são construídos com pelo menos duas saídas (caso contrário, os chamaríamos de cavernas). Um OpenVPN configurado corretamente no servidor direciona o tráfego para dentro e para fora do túnel de um lado. Mas você também precisará de algum software rodando do lado do cliente, ou seja, na outra extremidade do túnel.

Nesta seção, vou me concentrar na configuração manual de um computador Linux de algum tipo para funcionar como cliente OpenVPN. Mas esta não é a única maneira pela qual essa possibilidade está disponível. O OpenVPN suporta aplicativos clientes que podem ser instalados e usados em desktops e laptops com Windows ou macOS, bem como em smartphones e tablets com Android e iOS. Detalhes podem ser encontrados em openvpn.net.

O pacote OpenVPN precisará ser instalado no computador cliente, assim como foi instalado no servidor, embora não haja necessidade do easy-rsa, uma vez que as chaves que você está usando já existem. Você precisará copiar o arquivo modelo client.conf para o diretório /etc/openvpn/, que acaba de ser criado. Desta vez, o arquivo não será compactado, portanto, o comando cp funcionará perfeitamente para esta tarefa:

# apt install openvpn
# cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf 
  /etc/openvpn/

A maioria das configurações no seu arquivo client.conf será bastante compreensível: devem corresponder aos valores do servidor. Como pode ser visto no exemplo a seguir, o parâmetro único é remote 192.168.1.23 1194, que informa ao cliente o endereço IP do servidor. Novamente, verifique se este é o endereço do seu servidor. Você também deve fazer com que o computador cliente verifique a autenticidade do certificado do servidor para evitar um possível ataque de "homem no meio". Uma maneira de fazer isso é adicionar a linha remote-cert-tls server (listagem 10.3).

Agora você pode ir para o diretório /etc/openvpn/ e extrair as chaves de certificação do servidor. Substitua o endereço IP do servidor ou o nome de domínio no exemplo pelos seus valores:

Nada emocionante provavelmente acontecerá até que você inicie o OpenVPN no cliente. Como você precisa passar alguns argumentos, isso será feito a partir da linha de comando. O argumento —tls-client informa ao OpenVPN que você atuará como cliente e se conectará através da criptografia TLS, enquanto —config aponta para seu arquivo de configuração:

# openvpn --tls-client --config /etc/openvpn/client.conf

Leia atentamente a saída do comando para garantir que você está conectado corretamente. Se algo der errado na primeira vez, pode ser devido a uma discrepância nas configurações entre os arquivos de configuração do servidor e do cliente, ou a um problema de conexão de rede/firewall. Aqui estão algumas dicas de solução de problemas.

Leia atentamente a saída da operação OpenVPN no cliente. Ela muitas vezes contém dicas valiosas sobre o que não pode ser executado e por quê.
Verifique as mensagens de erro nos arquivos openvpn.log e openvpn-status.log no diretório /etc/openvpn/ no servidor.
Verifique as mensagens associadas ao OpenVPN e relevantes no horário nos logs do sistema no servidor e no cliente. (journalctl -ce exibirá as entradas mais recentes.)
Certifique-se de que há uma conexão de rede ativa entre o servidor e o cliente (mais detalhes no Capítulo 14).

Sobre o autor

David Clinton — administrador de sistema, instrutor e escritor. Ele administrou, escreveu sobre isso e criou materiais didáticos para muitas disciplinas técnicas importantes, incluindo sistemas Linux, computação em nuvem (especialmente AWS) e tecnologias de contêiner, como Docker. Ele escreveu o livro Learn Amazon Web Services in a Month of Lunches (Manning, 2017). Muitos de seus cursos em vídeo podem ser encontrados no site Pluralsight.com, e links para outros de seus livros (sobre administração de Linux e virtualização de servidores) estão disponíveis em bootstrap-it.com.

» Você pode se aprofundar no livro em site da editora
» Índice
» Trecho

Para os moradores do Habr, desconto de 25% com o cupom — Linux
Após o pagamento da versão impressa do livro, o e-book será enviado por e-mail.

Fonte: habr.com