Para configurar nosso servidor OpenVPN, precisaremos de um IP público para acessar o servidor. Uma vantagem interessante é que esse IP pode estar em “blackhole“, o que significa que ele não responderá a nenhuma porta indiscriminadamente, economizando recursos da CPU ao evitar a criação extensiva de regras de firewall. Vou ilustrar essa configuração com um exemplo prático:

Imagine que você adquiriu um MikroTik Hex RB750Gr3 para gerenciar sua rede interna. Você conecta esse dispositivo ao seu roteador de borda. Para configurar a comunicação, você estabelece um segmento de rede /30, por exemplo, 10.7.7.0/30. No roteador de borda, você configura o IP 10.7.7.1/30, e no seu Hex RB750Gr3, você configura o IP 10.7.7.2/30. Em seguida, você adiciona um gateway padrão com o IP 10.7.7.1 e configura na tabela de rotas o IP 250.250.250.250 em balckhole.

No roteador de borda, você cria uma rota estática com destino a 250.250.250.250 com gateway 10.7.7.2. Com isso, você estabelece um caminho direto para o seu IP público, mas sem responder a nenhuma solicitação de conexão externa.

Se você precisar acessar o dispositivo via Winbox, basta criar uma regra de redirecionamento (redirect) para essa porta específica, permitindo o acesso externo somente por ela. Usar um IP em “blackhole” é como ter um firewall que automaticamente descarta qualquer pacote não solicitado, proporcionando uma camada extra de segurança e eficiência.

Exemplo acima ficaria da seguinte forma:

Borda

# Adicione o IP à interface que comunica com sua HE
/ip address add address=10.7.7.1/30 comment="WAN" interface=ether1

# Cria rota estática dizendo que seu IP público está atrás do endereço "tal"
/ip route add comment="Rota_HEX" dst-address=250.250.250.250/32 gateway=10.7.7.2

Hex RB750Gr3

# Adicione o IP à interface que comunica com sua Borda
/ip address add address=10.7.7.2/30 comment="WAN" interface=ether1

# Adiciona um gateway
/ip route add comment="Gateway" dst-address=0.0.0.0/0 gateway=10.7.7.1

# Adiciona seu IP público em blackhole
/ip route add blackhole comment="Blackhole" dst-address=250.250.250.250/32

# Redirect para winbox (Não use porta padrão para segurança, ex: 61000)
/ip firewall nat add action=redirect chain=dstnat comment="Winbox" \
    dst-address=250.250.250.250 dst-port=61000 protocol=tcp to-ports=8291

Configurando o Servidor OpenVPN

Para a criação do servidor OpenVPN, será necessário gerar três certificados distintos. Seguem os passos detalhados:

Crie o certificado CA (Certificado de Autoridade)

Para iniciar, crie o certificado da Autoridade Certificadora (CA), que será a base da confiança dos certificados subsequentes:

/certificate add name=CA common-name=CA key-usage=crl-sign,key-cert-sign days-valid=36500

Após criar o certificado CA, você deve assiná-lo. Substitua 250.250.250.250 pelo seu IP público:

/certificate sign CA ca-crl-host=250.250.250.250

Crie e assine o certificado SERVIDOR

Este certificado será usado para autenticar o servidor durante as conexões:

/certificate add name=SERVIDOR common-name=SERVIDOR key-usage=digital-signature,key-encipherment,tls-server days-valid=36500
/certificate sign SERVIDOR ca=CA
/certificate set SERVIDOR trusted=yes

Crie e assine o certificado CLIENTE

Em seguida, crie o certificado do cliente, que será utilizado pelos clientes para estabelecer uma conexão segura com o servidor:

/certificate add name=CLIENTE common-name=CLIENTE key-usage=tls-client days-valid=36500
/certificate sign CLIENTE ca=CA

Exportação dos certificados

Por fim, exporte os certificados para arquivos PEM, o que facilitará a importação em diferentes clientes. Não se esqueça de substituir sup3s3nha0p3nvpn pela senha que protegerá o certificado do cliente:

/certificate export-certificate CA type=pem file-name=CA
/certificate export-certificate CLIENTE type=pem file-name=CLIENTE export-passphrase=sup3s3nha0p3nvpn

Este processo garante que tanto o servidor quanto os clientes possam estabelecer uma conexão VPN segura através do uso de certificados confiáveis.

Irá ser criado 3 arquivos CA.crt, CLIENTE.crt e CLIENTE.key

/file print 

 # NAME                             TYPE                                   SIZE CREATION-TIME       
 0 CA.crt                           .crt file                              1180 apr/12/2024 14:33:11
 1 CLIENTE.crt                      .crt file                              1143 apr/12/2024 14:33:16
 2 CLIENTE.key                      .key file                              1858 apr/12/2024 14:33:16

Pelo menu FILE do winbox faça download do mesmo se você estiver utilizando a versão 6 do RouterOS, para versão 7 não é necessário baixar, pois o mesmo tem um gerador que iremos ver mais a frente.

Agora vamos as configurações que serão entregues ao cliente. Crie uma pool qual será entregue.

/ip pool 
add name=POOL_OpenVPN ranges=192.168.250.128/25

Crie um o profile especifico para OPEN_VPN, no exemplo estou definindo também uma velocidade de 50MB de upload e download.

/ppp profile
add change-tcp-mss=yes local-address=192.168.250.1 name=OPEN_VPN rate-limit=50m/50m remote-address=POOL_OpenVPN use-encryption=yes

Se você deseja ser notificado via Telegram sempre que alguém se conectar ao seu servidor VPN (algo que eu recomendo e costumo fazer), você pode facilmente configurar essa integração editando o perfil no servidor e incluindo um script para enviar alertas. Para isso, siga os passos abaixo:

1. Acesse o perfil do servidor VPN (OPEN_VPN) e localize a aba “Scripts”.
2. Insira o script fornecido, substituindo `XXXXXXXXXXXXXXXXXXXXXX` pelo token do seu bot no Telegram, e `-10000000000` pelo ID do seu grupo ou usuário do Telegram.
# On Up:

:local callerId $"caller-id"
/tool fetch url="https://api.telegram.org/botXXXXXXXXXXXXXXXXXXXXXX/sendMessage\?parse_mode=HTML&chat_id=-10000000000&text=%E2%9D%8E%20OpenVPN%20ON%20USUARIO:%20<code>$user</code>%20ORIGEM:%20<code>$callerId</code>&disable_web_page_preview=true" keep-result=no

# On Down:

:local callerId $"caller-id"
/tool fetch url="https://api.telegram.org/botXXXXXXXXXXXXXXXXXXXXXX/sendMessage\?parse_mode=HTML&chat_id=-10000000000&text=%E2%9D%8C%20OpenVPN%20OFF%20USUARIO:%20<code>$user</code>%20ORIGEM:%20<code>$callerId</code>&disable_web_page_preview=true" keep-result=no

Esse ajuste permitirá que você receba uma notificação imediata sempre que ocorrer uma conexão, aumentando o controle e a segurança da sua rede.

Faça uma regra de NAT (src-nat) para fornecer internet ao cliente, onde 250.250.250.250 é nosso querido IP que está em blackhole, e ether1 seria minha interface WAN (Upstream)

/ip firewall nat
add action=src-nat chain=srcnat comment="NAT_OpenVPN" out-interface=ether1 \
    src-address=192.168.250.128/25 to-addresses=250.250.250.250

Iremos ativar o servidor OpenVPN agora, a porta padrão é a 1194, porem estarei adotando a boa pratica de utilizar outra como a 61194

/interface ovpn-server server
add name=open-vpn-server \
 auth=sha1 \
 certificate=SERVIDOR \
 cipher=aes256-cbc \
 default-profile=OPEN_VPN \
 require-client-certificate=yes \
 port=61194 \
 redirect-gateway=def1

/interface ovpn-server server print
/interface ovpn-server server enable 0

Crie seus usuários, vou criar um de exemplo:

/ppp secret add comment="Key: sup3s3nha0p3nvpn" name=remontti@remontti.vpn profile=OPEN_VPN service=ovpn password=su4senhAparaL0gar 

Você pode também utilizar os usuários via Radius, basta fazer a integração. Exemplo:

/ppp aaa set interim-update=5m use-radius=yes
/radius add address=10.10.10.10 secret=senha service=ppp

Na versão 7 do routerOS podemos criar nosso arquivo.ovpn direto pelo botão Export .ovpn

Altere server-address para seu endereço de ip público.

/interface ovpn-server server export-client-configuration \
  server-address=250.250.250.250 \
  ca-certificate=CA.crt \
  client-certificate=CLIENTE.crt \
  client-cert-key=CLIENTE.key \
  server=open-vpn-server 

Se estiver utilizando o ip em blackhole vc precisa fazer o redirect para porta que irá utilizar ex.: “61194”

/ip firewall nat add action=redirect chain=dstnat comment="OpenVPN" \
    dst-address=250.250.250.250 dst-port=61194 protocol=tcp to-ports=61194

Veja os arquivos novamente.

/file print 

Perceba que temos agora um novo arquivo client1712413538.ovpn, faça donwload do mesmo e pule a próxima etapa da versão 6 direto para configuração do cliente OpenVPN.

#  NAME                   TYPE        SIZE  CREATION-TIME      
0  CLIENTE.key            .key file   1858  2024-04-06 10:53:13
1  client1712413538.ovpn  .ovpn file  4393  2024-04-06 11:25:38
2  CLIENTE.crt            .crt file   1090  2024-04-06 10:53:13
3  CA.crt                 .crt file   1123  2024-04-06 10:53:07

Cliente OpenVPN

Acessando https://openvpn.net/client/ voce encontra cliente para Windows, MacOS, Linux, Android, iOS e ChromeOS.

Com o cliente instalado basta você importar o arquivo .ovpn e infomar seu usuário e senha, ao conectar pela primeira vez irá solicitar a chave do certificado.

No linux você pode configurar também automaticamente nas configurações de rede sem a necessidade de instalar nenhum programa.

Gostou? Quer ajudar manter o blog?

Se quiser fazer uma doação para o café ficarei muito feliz pelo seu reconhecimento!

Se não puder doar pode deixar seu agradecimento nos comentário também ficarei feliz em saber que ajudei. Se tiver qualquer pergunta deixe-a também. Se preferir entrar em Contato clique aqui.

O post Configurando OpenVPN no RouterOS v7 apareceu primeiro em Remontti.

Vou ensinar realizar Port knocking no Linux com nftables e iptables e Mikrotik

Primeiramente precisamos escolher 4 portas que iremos bater para ganhar acesso.
No meu exemplo irei usar as portas: 52341, 28001, 60541, 30951

Neste exemplo vou estar liberando as portas 22 e 23 após “batermos” nas portas 52341, 28001, 60541, 30951, e por 1min após bater nas portas teremos acesso as portas 22 e 23.

Se você é amante de linux, e seu desktop é um lindo linux instale o “batedor” knockd, não vamos usa-lo ainda, mas já podemos instala-lo!

$ sudo apt install knockd
$ knock -h
  -u, --udp       make all ports hits use UDP (default is TCP)
  -d, --delay <t>      wait <t> milliseconds between port hits
  -v, --verbose   be verbose
  -V, --version   display version
  -h, --help      this help

Ele funciona assim:

$ knock -d 500 -v 192.168.1.1 52341 28001 60541 30951
hitting tcp 192.168.1.1:52341
hitting tcp 192.168.1.1:28001
hitting tcp 192.168.1.1:60541
hitting tcp 192.168.1.1:30951

Linux Nftables

Primeiramente tenha o nftables instalado. Para distribuição baseadas em Debian use:

# apt install nftables
# systemctl enable nftables.service

O arquivo de configuração padrão do nftables fica em /etc/nftables.conf, então vamos edita-lo:

# vim /etc/nftables.conf

Lembre-se de criar o seu padrão de sequencia e portas, e adicione ao final do arquivo:

define protege_portas = {22,23}

table inet portknock {
   set clientes_ipv4 {
      type ipv4_addr
      flags timeout
   }

   set clientes_ipv6 {
      type ipv6_addr
      flags timeout
   }

   set toctoc_aberta_ipv4 {
      type ipv4_addr . inet_service
      flags timeout
   }

   set toctoc_aberta_ipv6 {
      type ipv6_addr . inet_service
      flags timeout
   }

   chain input {
      type filter hook input priority -10; policy accept;

      iifname "lo" return

      tcp dport 52341 add @toctoc_aberta_ipv4 {ip  saddr . 28001 timeout 60s}
      tcp dport 52341 add @toctoc_aberta_ipv6 {ip6 saddr . 28001 timeout 60s}
      tcp dport 28001 ip  saddr . tcp dport @toctoc_aberta_ipv4 add @toctoc_aberta_ipv4 {ip  saddr . 60541 timeout 60s}
      tcp dport 28001 ip6 saddr . tcp dport @toctoc_aberta_ipv6 add @toctoc_aberta_ipv6 {ip6 saddr . 60541 timeout 60s}
      tcp dport 60541 ip  saddr . tcp dport @toctoc_aberta_ipv4 add @toctoc_aberta_ipv4 {ip  saddr . 30951 timeout 60s}
      tcp dport 60541 ip6 saddr . tcp dport @toctoc_aberta_ipv6 add @toctoc_aberta_ipv6 {ip6 saddr . 30951 timeout 60s}
      tcp dport 30951 ip  saddr . tcp dport @toctoc_aberta_ipv4 add @clientes_ipv4 {ip  saddr timeout 10s} log prefix "Portknock bem-sucedido: "
      tcp dport 30951 ip6 saddr . tcp dport @toctoc_aberta_ipv6 add @clientes_ipv6 {ip6 saddr timeout 10s} log prefix "Portknock bem-sucedido: "

      tcp dport { $protege_portas } ip  saddr @clientes_ipv4 counter accept
      tcp dport { $protege_portas } ip6 saddr @clientes_ipv6 counter accept
      tcp dport { $protege_portas } ct state established,related counter accept
      tcp dport { $protege_portas } counter reject with tcp reset
   }
}

Restarte o nftables

# systemctl enable nftables.service

Se você não usa linux em seu deskop para usar o knock, basta você jogar no seu navegador ip:porta, ex 192.168.1.1:52341 192.168.1.1:28001 192.168.1.1:60541 192.168.1.1:30951, lembre-se que você tem 1 minuto para bater nas portas e realizar sua conexão. Já já ensino como ter um servido web e liberar a porta em um click!

$ knock -d 500 -v 192.168.1.1 52341 28001 60541 30951

Para acompanhar os logs:

#  tail -f /var/log/messages

Realize o SSH (ou acesse o a porta que tenha protegido para testar)

Linux Iptables

Vou deixar um modelo com iptables, mas recomendo você ir migrando para nftables que em um futuro sera seu sucessor. Não esqueça de alterar as portas para sua realidade, em seu arquivo de firewall tenha:

#!/bin/bash
iptables -F
iptables -X
iptables -Z

iptables -N INTO-TOCTOC2
iptables -A INTO-TOCTOC2 -m recent --name TOCTOC1 --remove
iptables -A INTO-TOCTOC2 -m recent --name TOCTOC2 --set

iptables -N INTO-TOCTOC3
iptables -A INTO-TOCTOC3 -m recent --name TOCTOC2 --remove
iptables -A INTO-TOCTOC3 -m recent --name TOCTOC3 --set

iptables -N INTO-TOCTOC4
iptables -A INTO-TOCTOC4 -m recent --name TOCTOC3 --remove
iptables -A INTO-TOCTOC4 -m recent --name TOCTOC4 --set
iptables -A INTO-TOCTOC4 -j LOG --log-prefix "Portknock bem-sucedido: "

iptables -A INPUT -m recent --update --name TOCTOC1

iptables -A INPUT -p tcp --dport 52341 -m recent --set --name TOCTOC1
iptables -A INPUT -p tcp --dport 28001 -m recent --rcheck --seconds 30 --name TOCTOC1 -j INTO-TOCTOC2
iptables -A INPUT -p tcp --dport 60541 -m recent --rcheck --seconds 30 --name TOCTOC2 -j INTO-TOCTOC3
iptables -A INPUT -p tcp --dport 30951 -m recent --rcheck --seconds 60 --name TOCTOC3 -j INTO-TOCTOC4

# Para uma unica porta
#iptables -A INPUT -p tcp --dport 22 -m state --state ESTABLISHED,RELATED -j ACCEPT
#iptables -A INPUT -p tcp --dport 22 -m recent --rcheck --seconds 60 --name TOCTOC4 -j ACCEPT
#iptables -A INPUT -p tcp --dport 22 -j DROP

# Multiplas portas
iptables -A INPUT -p tcp -m multiport --dport 22,23 -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -p tcp -m multiport --dport 22,23 -m recent --rcheck --seconds 60 --name TOCTOC4 -j ACCEPT
iptables -A INPUT -p tcp -m multiport --dport 22,23 -j DROP

Pode realizar os mesmo procedimento anteriores

Mikrotik

Aqui vai uma observação muito importante para quem usa routerOS, FIREWALL TEM LUGAR PARA SER FEITO, então não sai aplicando Port Knocking em todo o lugar. Por exemplo, muitos provedores tem o costume de deixar na sua borda routerOS o serviço PPTP ativo para fazer uma conexão quando esta fora da sua rede, este é um bom exemplo de NÃO se seguir, routerOS tem q ter muito cuidado quando se cria firewall, recomendo que para esse tipo de serviço como PPTP Server, seja rodado em um router paralelo (pode ser uma hAP lite, uma VM com o routerOS mas nunca em uma borda) até por que é muito fácil de quebrar o PPTP, então para não deixar a porta 1723/PPTP aberta iremos realizar o Port Knocking, aproveitei e inclui a porta 22, altere de acordo com suas necessidades.

/ip firewall filter
add action=add-src-to-address-list address-list=toc_toc_1  \
    address-list-timeout=30s chain=input comment="Port Knocking"  \
    connection-state=new dst-port=52341 protocol=tcp
add action=add-src-to-address-list address-list=toc_toc_2  \
    address-list-timeout=30s chain=input connection-state=new dst-port=28001  \
    protocol=tcp src-address-list=toc_toc_1
add action=add-src-to-address-list address-list=toc_toc_3  \
    address-list-timeout=30s chain=input connection-state=new dst-port=60541  \
    protocol=tcp src-address-list=toc_toc_2
add action=add-src-to-address-list address-list=toc_toc_4 address-list-timeout=2m  \
    chain=input connection-state=new dst-port=30951 log=yes log-prefix="Portknock bem-sucedido"  \
    protocol=tcp src-address-list=toc_toc_3
add action=drop chain=input connection-state=new dst-port=1723,22  \
    protocol=tcp src-address-list=!toc_toc_4

Se você não usa linux em seu deskop para usar o knock, basta você jogar no seu navegador ip:porta, ex 192.168.1.1:52341 192.168.1.1:28001 192.168.1.1:60541 192.168.1.1:30951, lembre-se que você tem 1 minuto para bater nas portas e realizar sua conexão. Já já ensino como ter um servido web e liberar a porta em um click!

$ knock -d 500 -v 192.168.1.1 52341 28001 60541 30951

para acompanhar, abra os Log sempre que um host acertar as sequencias de porta um log com Portknock bem-sucedido será exibido. Verifique também em IP-> Firewall -> Address List.

Realize o sua conexão PPTP ou SSH (ou acesse o a porta que tenha protegido para testar)

Que tal uma central “toc toc” para nosso Port knocking

Leituras recomendadas:
Como ter diversos sub/domínios no mesmo servidor?
Passo-a-passo como criar um servidor WEB
Servidor DNS seguro com Bind9
Crie um subdomínio em exemplo toctoc em seu servidor DNS apontando para algum servidor web que você tenha rodando.
Ajustes o subdomíno em seu servidor web, neste ex com apache estou estarei incluído uma senha para acesso.

# mkdir /var/www/toctoc/
# htpasswd -c /var/www/toctoc/.htpasswd admin

E defina a senha para seu acesso.

# vim /etc/apache2/sites-available/toctoc.conf

<virtualhost *:80>
   ServerName toctoc.remontti.com.br
   ServerAdmin noc@remontti.com.br
   DocumentRoot /var/www/toctoc
   <Directory /var/www/toctoc/>
      Options FollowSymLinks
      AllowOverride All
      Require all denied
      <RequireAll>
          Require valid-user
          AuthBasicProvider file
          AuthType Basic
          AuthName "Login"
          AuthUserFile /var/www/toctoc/.htpasswd
      </RequireAll>
   </Directory> 
   ErrorLog ${APACHE_LOG_DIR}/error_toctoc.log
   CustomLog ${APACHE_LOG_DIR}/access_toctoc.log combined
</VirtualHost>

Criei uma paginazinha com php + javascript para executar nosso trabalho para não precisar decorar portas, sinta-se a vontade para melhorar o código: https://github.com/remontti/PortKnockingPHP

# cd /var/www/toctoc/
# wget https://raw.githubusercontent.com/remontti/PortKnockingPHP/main/index.php

Edite o arquivo index.php e altere a lista de seus servidores…

 # Nome - IP - Porta 1 - Porta 2 - Porta 3 - Porta 4 #
$array = [
    ["RouterOS PPTP","192.168.1.1","1000","2000","3000","4000"],
    ["Servicor 2","192.168.2.1","111","222","333","4444"],
    ["Servicor 3","192.168.3.1","1000","2000","3000","4000"],
    ["Servicor 4","192.168.4.1","1000","2000","3000","4000"],
];

Agora acesse seu “toctoc.remontti.com.br” e seja feliz, e não se preocupe em estar decorando portas, basta você clicar em Toc Toc.

Aplicativos para Celular/PC Windows

Dica dos leitores
Para iPhone: https://apps.apple.com/us/app/knockond/id333206277
Para Android: https://play.google.com/store/apps/details?id=com.xargsgrep.portknocker&hl=pt_BR&gl=US
Para PC Win.: http://gregsowell.com/?p=2020

Espero que tenha gostado!

Se quiser fazer uma doação para o café ficarei muito feliz pelo seu reconhecimento!

Participe do canal no telegram para ficar atualizado sempre que publicar um novo tutorial.

Se não puder doar pode deixar seu agradecimento nos comentário também ficarei feliz em saber que ajudei. Se tiver qualquer pergunta deixe-a também. Se preferir entrar em Contato clique aqui.

O post Port knocking, aprenda a melhorar as política de segurança de seu firewall Linux e Mikrotik apareceu primeiro em Remontti.