A proteção de um servidor pode ser alcançada através do controlo de portas, bloqueando-as no firewall, incluindo aquelas que são necessárias. Estas portas são ativadas apenas quando uma solicitação de conexão apresenta a sequência correta, funcionando como uma “batida secreta”.
Port Knocking: Uma “Batida Secreta” Digital
Tal como nos tempos da Lei Seca, onde era necessário conhecer a senha para entrar num bar clandestino, o “port knocking” funciona de forma semelhante no mundo digital. Se pretende conceder acesso a serviços no seu computador, mas sem abrir o firewall para a internet, esta técnica permite fechar as portas de firewall que aceitam conexões de entrada e abri-las automaticamente mediante uma sequência específica de tentativas de conexão. Esta sequência funciona como uma “batida secreta”, e outra sequência pode ser usada para fechar a porta novamente.
Apesar de ser uma técnica interessante, é crucial entender que o “port knocking” é um exemplo de segurança por obscuridade, um conceito com falhas inerentes. A segurança reside no segredo, acessível apenas a um grupo seleto. No entanto, assim que o segredo é descoberto, seja por revelação, observação, adivinhação ou engenharia, a segurança desaparece. É preferível proteger o seu servidor através de métodos mais robustos, como logins com base em chave para um servidor SSH.
As melhores práticas de cibersegurança são construídas em camadas, e o “port knocking” pode ser considerado uma dessas camadas. Contudo, alguns podem argumentar que a sua contribuição para um sistema seguro e robusto é mínima, senão inexistente.
A cibersegurança é um tema amplo e complexo, e o “port knocking” não deve ser a sua única linha de defesa.
Instalação do knockd
Para demonstrar o funcionamento do “port knocking”, vamos utilizá-lo para controlar a porta 22, usada pelo SSH. Iremos usar uma ferramenta chamada knockd. Para sistemas Ubuntu ou Debian, use o comando `apt-get` para instalar este pacote. Em outras distribuições Linux, use o gestor de pacotes correspondente.
Execute o seguinte comando:
sudo apt-get install knockd
O firewall iptables deve estar instalado no seu sistema, mas pode ser necessário instalar o pacote `iptables-persistent`, que lida com o carregamento automático das regras iptable.
Para instalar, execute:
sudo apt-get install iptables-persistent
Na tela de configuração IPV4, pressione a barra de espaço para selecionar “Sim”.
Faça o mesmo na tela de configuração IPv6 para avançar.
O comando seguinte permite que as conexões estabelecidas continuem. Vamos agora fechar a porta SSH:
Se houver alguém conectado via SSH, não queremos que a conexão seja terminada:
sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
Este comando adiciona uma regra ao firewall que indica:
- `-A`: Acrescenta a regra ao final da tabela de regras.
- `INPUT`: A regra refere-se a conexões de entrada.
- `-m conntrack`: Usa um módulo para o rastreamento de conexões, `conntrack`.
- `–ctstate ESTABLISHED, RELATED`: Aplica-se a conexões estabelecidas e relacionadas. Conexões estabelecidas são as que já estão em andamento, e conexões relacionadas são iniciadas devido a uma ação de uma conexão estabelecida.
- `-j ACCEPT`: Se o tráfego corresponde à regra, é aceito.
Agora, vamos fechar a porta SSH:
sudo iptables -A INPUT -p tcp --dport 22 -j REJECT
Esta regra de firewall indica:
- `-A`: Adiciona a regra ao final da tabela de regras.
- `INPUT`: A regra refere-se a conexões de entrada.
- `-p tcp`: A regra aplica-se ao tráfego TCP.
- `–dport 22`: A regra aplica-se especificamente à porta 22 (SSH).
- `-j REJECT`: Se o tráfego corresponde à regra, é rejeitado.
É necessário iniciar o serviço `netfilter-persistent`:
sudo systemctl start netfilter-persistent
O `netfilter-persistent` precisa de guardar e recarregar, controlando as regras de iptable.
Execute os seguintes comandos:
sudo netfilter-persistent save
sudo netfilter-persistent reload
Agora, o utilitário está instalado e a porta SSH está fechada (sem terminar a sessão de ninguém). Vamos configurar a sequência secreta.
Configuração do knockd
A configuração do `knockd` envolve a edição de dois ficheiros. O primeiro é o ficheiro de configuração:
sudo gedit /etc/knockd.conf
O editor `gedit` abre com o arquivo de configuração do `knockd`.
Vamos editar as seções “openSSH” e “closeSSH”, que contêm as seguintes entradas:
- `sequence`: A sequência de portas que devem ser acessadas para abrir ou fechar a porta 22. As portas padrão são 7000, 8000 e 9000 para abrir, e 9000, 8000 e 7000 para fechar.
- `seq_timeout`: O período de tempo para que a sequência seja válida.
- `command`: O comando enviado para o firewall iptables quando a sequência é acionada. Estes comandos adicionam ou removem uma regra do firewall.
- `tcpflags`: O tipo de pacote que cada porta deve receber na sequência secreta. Um pacote SYN (synchronize) é o primeiro em uma conexão TCP, parte do “handshake” de três vias.
A seção “openSSH” pode ser interpretada como: “uma solicitação de conexão TCP deve ser feita às portas 7000, 8000 e 9000, nesta ordem e dentro de 5 segundos, para que o comando de abertura da porta 22 seja enviado ao firewall”.
A seção “closeSSH” é semelhante: “uma solicitação de conexão TCP deve ser feita às portas 9000, 8000 e 7000, nesta ordem e dentro de 5 segundos, para que o comando de fecho da porta 22 seja enviado ao firewall”.
As regras do firewall
As entradas de “comando” nas seções `openSSH` e `closeSSH` são semelhantes, com exceção de um parâmetro:
- `-A`: Acrescenta a regra ao final da lista de regras do firewall (comando openSSH).
- `-D`: Remove a regra da lista de regras do firewall (comando closeSSH).
- `INPUT`: Refere-se ao tráfego de entrada.
- `-s %IP%`: O endereço IP do dispositivo que está solicitando a conexão.
- `-p tcp`: O protocolo de rede (TCP).
- `–dport`: A porta de destino (porta 22).
- `-j ACCEPT`: Permite que o pacote passe através do firewall.
Alterações no arquivo de configuração do knockd
As alterações feitas no arquivo são destacadas abaixo:
Aumentamos o `seq_timeout` para 15 segundos. Isto dá mais tempo para alguém que envia os pedidos de conexão manualmente.
Na seção “openSSH”, alteramos a opção -A (append) para -I (insert) no comando. Este comando insere uma nova regra de firewall no topo da lista de regras. Deixar a opção -A adiciona a regra ao final da lista.
O tráfego de entrada é avaliado em relação a cada regra do firewall de cima para baixo. Como já temos uma regra que fecha a porta 22, se o tráfego for avaliado contra esta regra antes de ver a regra que permite o acesso, a conexão será recusada. Inserir a regra no topo garante que o tráfego seja permitido.
O comando `close` remove a regra adicionada pelo comando `openSSH`. O tráfego SSH é então tratado pela regra que fecha a porta 22.
Depois destas edições, salve o ficheiro de configuração.
Alterações no ficheiro de controlo do Knockd
O ficheiro de controlo do `knockd` é mais simples. Para o editar, precisamos do nome da interface de rede. Para tal, execute o comando:
ip addr
Neste caso, a interface de rede é `enp0s3`. Anote o nome da sua conexão.
Execute o seguinte comando para editar o ficheiro de controlo do `knockd`:
sudo gedit /etc/default/knockd
Segue o ficheiro do `knockd` no `gedit`:
As alterações necessárias são destacadas:
Altere o valor da entrada `START_KNOCKD =` de 0 para 1.
Remova o `#` do início da entrada `KNOCKD_OPTS =` e substitua `eth1` pelo nome da sua interface de rede, neste caso `enp0s3`. Se a sua interface for `eth1`, não precisa de alterar.
A prova dos nove
É hora de verificar se tudo funciona. Inicie o serviço `knockd` com:
sudo systemctl start knockd
Vamos agora ligar-nos a partir de outro computador. Instalamos o `knockd` neste computador também, não para usar o “port knocking”, mas porque o pacote inclui outra ferramenta chamada `knock`. Este computador será usado para enviar a sequência secreta.
Use o seguinte comando para enviar a sequência secreta para o computador com o IP 192.168.4.24:
knock 192.168.4.24 7000 8000 9000 -d 500
Isto envia solicitações de conexão para as portas 7000, 8000 e 9000, com um atraso de 500 milissegundos.
O utilizador “dave” faz um pedido de ligação SSH para 192.168.4.24:
ssh [email protected]
A conexão é aceite e ele inicia a sua sessão remota. O prompt muda de [email protected] para [email protected]. Para sair, ele digita:
exit
O prompt volta para o computador local. Ele usa o comando `knock` mais uma vez para fechar a porta:
knock 192.168.4.24 9000 8000 7000 -d 500
Esta não foi uma sessão remota muito longa, mas demonstra o funcionamento do “port knocking” em apenas uma captura de ecrã.
E do lado do servidor? O administrador usa o seguinte comando para visualizar as novas entradas no log do sistema:
tail -f /var/log/syslog
Existem três entradas `openSSH`. Estas aumentam à medida que o utilitário `knock` envia as solicitações para as portas. Quando a sequência é completa, surge a entrada “ABRE-TE SÉSAMO”.
O comando para inserir a regra na lista do `iptables` é enviado. Isto permite o acesso via SSH na porta 22 para o endereço IP que enviou a sequência secreta (192.168.4.23).
O utilizador “dave” conecta-se e desconecta-se. Em seguida, existem três entradas `closeSSH`. Estas aumentam à medida que o utilitário `knock` envia solicitações para as portas, sinalizando ao servidor para fechar a porta 22.
Após completar a sequência, recebemos novamente a mensagem “ABRIR SÉSAMO”. O comando é enviado para remover a regra do firewall. (Por que não “FECHAR SÉSAMO” quando fecha a porta?)
A única regra na lista do `iptables` referente à porta 22 é a que digitamos no início, que fecha a porta. Assim, a porta 22 está novamente fechada.
Atenção
Este é o funcionamento do “port knocking”. Utilize esta técnica como um experimento e não como método de segurança. Ou, se o fizer, não confie apenas nela.