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.

Este tutorial combina e aprimora dois tutoriais anteriores do blog sobre fastnetmon, incorporando melhorias e ideias compartilhadas pela comunidade ao longo do tempo. Espero que aprecie!

Vamos aprender como identificar os ataques Dos/DDoS e anunciar os prefixo atacados (ou atacantes) de seu AS em envia-los para uma blackhole, e repassar os mesmo para sua operadora. (Acordo)

Vamos utilizar o FastNetMon (Community Edition) que é um analisador de carga DoS/DDoS de alto desempenho, construído sobre vários mecanismos de captura de pacotes (NetFlow, IPFIX, sFlow, AF_PACKET, SnabbSwitch, netmap, PF_RING, PCAP).

Farei a instalação no Debian 12 (Instalação Limpa). O hardware utilizado por ser bem generoso, 4CPU (se for usar o influx/grafana recomendo 8CPU) e 4GB de memoria.

Adicione contrib non-free ao repositório.

# vim /etc/apt/sources.list

Irá ficar assim:

deb http://deb.debian.org/debian/ bookworm main non-free-firmware contrib non-free
deb-src http://deb.debian.org/debian/ bookworm main non-free-firmware contrib non-free

deb http://security.debian.org/debian-security bookworm-security main non-free-firmware contrib non-free
deb-src http://security.debian.org/debian-security bookworm-security main non-free-firmware contrib non-free

deb http://deb.debian.org/debian/ bookworm-updates main non-free-firmware contrib non-free
deb-src http://deb.debian.org/debian/ bookworm-updates main non-free-firmware contrib non-free

Atualize agora o repositório, e os pacotes.

# apt update ; apt upgrade -y
# apt install firmware-linux firmware-linux-free firmware-linux-nonfree

Instale também alguns pacotes que iremos utilizar mais a frente.

# apt install wget tcpdump net-tools zip curl -y

Cenário fictício de exemplo:
Seu AS: 260072 (Madruga Telecom)
Operadora AS: 71 (BrUxa71 Telecom)
10.52.52.1/24 – Huawei/RouterOS
10.52.52.2/24 – Servidor

Configurando a interface de Rede

Antes de iniciar a instalação do seu do seu servidor em meu exemplo estou usando o IP 10.52.52.2/30, porém eu NUNCA faria um NAT no roteador de borda então porque utilizar o IP privado? Simples por que ele não é acessível logo não pode ser atacado, mas por outro lado se ele não tiver internet você não poderá fazer a instalação e ele não poderá te notificar pelo telegram. Solução que eu gosto muito de aplicar em servidores é a seguinte (falo muito de como configurar interface de redes nesse tutorial, recomendo uma leitura).

Vamos supor que seu prefixo seja 72.72.72.0/22 e você vai alocar o ip 72.72.72.255/32 para ser o IP de “loopback”. Dica que esse IP não seja próximo a do prefixo público que utiliza em seus servidores. Irei também configurar um IPv6 roteador da mesma forma para que ele tenha uma conectividade IPv6 qual o telegram pode se beneficiar para enviar um alerta por exemplo.

# vim /etc/network/interfaces

allow-hotplug enp0s3
iface enp0s3 inet static
    address 72.72.72.255/32

iface enp0s3 inet static
    address 10.52.52.2/24
    post-up /usr/sbin/ip route add default via 10.52.52.1 src 72.72.72.255

iface enp0s3 inet6 static
    pre-up modprobe ipv6
    address 2804:1234:bebe:caff::f0da/128

iface enp0s3 inet6 static
    pre-up modprobe ipv6
    address fd00:cafe::2/64
    post-up ip -6 route add default via fd00:cafe::1 src 2804:1234:bebe:caff:1:f0da:2:ff1f

Perceba que nós estaremos conversando com nosso roteador de borda pelo prefixo privado 10.100.0.0/30 porém todo o pacote de origem do servidor sai pelo o IP público. Caso este ip seja atacado o mesmo poderá cair em blackhole que o nosso servidor ainda terá comunicação com a borda.

Mas para que seu IP publico tenha rota será necessário criar um rota em seu roteador de borda apontando o IP público para o privado.

RouterOS# /ip   address add interface=ether1 address=10.52.52.1/24
RouterOS# /ipv6 address add interface=ether1 address=fd00:cafe::1/64 advertise=no 
RouterOS# /ip   route add dst-address=72.72.72.255/32 gateway=10.52.52.2
RouterOS# /ipv6 route add dst-address=2804:1234:bebe:caff:1:f0da:2:ff1f/128 gateway=fd00:cafe::1

<HUAWEI> system-view
[~HUAWEI] interface 25GE0/1/36
[*HUAWEI] description INTERFACE_SERVIDOR
[*HUAWEI] undo shutdown
[*HUAWEI] ipv6 enable
[*HUAWEI] ip address 10.52.52.1 255.255.255.0
[*HUAWEI] ipv6 address FD00:CAFE::1/64
[*HUAWEI] quit
[*HUAWEI] ip route-static 72.72.72.255 255.255.255.255 10.52.52.2 description FASTNETMON
[*HUAWEI] ipv6 route-static 2804:1234:bebe:caff:1:f0da:2:ff1f 128 2001:FD00:CAFE::1 description FASTNETMON
[*HUAWEI] commit

É claro que neste caso ficará sem internet, mas podemos aplicar um firewall para enviar que ele fique respondendo, apenas para deixar ele “escondidinho”. E para isso vamos usar o nftables (Que já vem instalado por padrão no Debian 11 substituindo o iptables)
Habilite o mesmo para iniciar com o sistema:

# systemctl enable nftables

Vamos montar nosso firewall de forma que apenas conexoes que forem abertas pelo servidor seja respondidas.

# vim /etc/nftables.conf

#!/usr/sbin/nft -f

flush ruleset

# IP SERVIDOR
define IPV4_SERV = { 72.72.72.255 }
define IPV6_SERV = { 2804:1234:bebe:caff:1:f0da:2:ff1f }

# Portas aberta para ADM (vou deixar só SSH e a do Grafana)
define PORTS_ACCEP_ADM = { 22, 3000 }

table inet filter {

    set ACESSO_TOTAL4 {
        type ipv4_addr
        flags interval
        # Lista dos IPv4 com permissão
        elements = {
            127.0.0.0/8,
            192.168.0.0/16,
            172.16.0.0/12,
            10.0.0.0/8,
            100.64.0.0/10,
            72.72.72.0/24
        }
    }
    set ACESSO_TOTAL6 {
        type ipv6_addr
        flags interval
        # Lista dos IPv6 com permissão
        elements = {
            ::1,
            2804:1234:bebe::/48
        }
    }

    chain input {
        type filter hook input priority 0;

        # Aceita ICMP apenas das origens com permissão
        ip saddr @ACESSO_TOTAL4 ip protocol icmp icmp type echo-request accept
        ip6 nexthdr icmpv6 ip6 saddr @ACESSO_TOTAL6 icmpv6 type echo-request accept

        # Permite acesso as portas vindo das origens com permissão
        ip  saddr @ACESSO_TOTAL4 tcp dport { $PORTS_ACCEP_ADM } counter accept
        ip6 saddr @ACESSO_TOTAL6 tcp dport { $PORTS_ACCEP_ADM } counter accept

        # Fecha todo resto
        ip  daddr { $IPV4_SERV } ct state related,established counter accept
        ip  daddr { $IPV4_SERV } counter drop
        ip6 daddr { $IPV6_SERV } ct state related,established counter accept
        ip6 daddr { $IPV6_SERV }  counter drop

        type filter hook input priority 0;
    }
    chain forward {
        type filter hook forward priority 0;
    }
    chain output {
        type filter hook output priority 0;
    }
}

Inicie o nftables

# systemctl enable nftables
# systemctl start nftables

Você pode simplesmente rodar um scanner de porta no seu IP público bem como um ping, o mesmo não deve responde.

Instalação FastNetMon (Edição da comunidade)

FastNetMon se encontra no repositório do Debian 12

# apt search fastnetmon

Sorting... Pronto
Full Text Search... Pronto
fastnetmon/testing 1.2.4-2 amd64
  fast DDoS analyzer with sflow/netflow/mirror support (community edition)

# apt install fastnetmon -y

Adicione todos os prefixos do seu AS, são esses os IPs serão feito analise. Dica: se você for usar o grafana recomendo cadastras todos os prefixos /24 para poder visualizar o trafego de cada prefixo em especifico

# vim /etc/networks_list

72.72.72.0/24
72.72.73.0/24
72.72.74.0/24
72.72.75.0/24

Crie também o arquivo que irá conter a lista branca de IPs (Explico mais a frente)

# > /etc/networks_whitelist

As configurações do Fastnetmon ficam em /etc/fastnetmon.conf, vamos fazer alguns ajustes básicos:
Vamos começar ativando o serviço de netflow. Utilizarei o comando sed que irá buscar no arquivo netflow = off e alterar para netflow = on, nos comandos seguintes farei o mesmo, se desejar acesse o arquivo e edite manualmente.

# sed -i 's/netflow = off/netflow = on/' /etc/fastnetmon.conf

Ajustes para Huawei

# sed -i 's/average_calculation_time = 5/average_calculation_time = 15/' /etc/fastnetmon.conf
# sed -i 's/netflow_sampling_ratio = 1/netflow_sampling_ratio = 1024/' /etc/fastnetmon.conf

Ajustes para Mikrotik

# Não precisa alterar nada aqui

Defina por quanto tempo em segundos um IP ficará em blackhole o padrão é 1900 seg. No comando estou alterando para 10min:

# sed -i 's/ban_time = 1900/ban_time = 600/' /etc/fastnetmon.conf

Altera o top 7 para o top 10 ao usar o comando fastnetmon_client (Ao seu gosto)

# sed -i 's/max_ips_in_list = 7/max_ips_in_list = 10/' /etc/fastnetmon.conf

Temos diferentes abordagens para detecção dos ataques: Pacotes por segundos, largura de banda e por fluxo (flows), protocolos, nessa parte irei habilitar todos filtros, mas cada caso é uma realidade.

# sed -i 's/ban_for_flows = off/ban_for_flows = on/' /etc/fastnetmon.conf
# sed -i 's/ban_for_tcp_bandwidth = off/ban_for_tcp_bandwidth = on/' /etc/fastnetmon.conf
# sed -i 's/ban_for_udp_bandwidth = off/ban_for_udp_bandwidth = on/' /etc/fastnetmon.conf
# sed -i 's/ban_for_icmp_bandwidth = off/ban_for_icmp_bandwidth = on/' /etc/fastnetmon.conf
# sed -i 's/ban_for_tcp_pps = off/ban_for_tcp_pps = on/' /etc/fastnetmon.conf
# sed -i 's/ban_for_udp_pps = off/ban_for_udp_pps = on/' /etc/fastnetmon.conf
# sed -i 's/ban_for_icmp_pps = off/ban_for_icmp_pps = on/' /etc/fastnetmon.conf

Se desejar ter mais detalhes no log, aumenta de 20 para até 200 linhas de registro no log.

# sed -i 's/ban_details_records_count = 20/ban_details_records_count = 200/' /etc/fastnetmon.conf

Como temos todas as detecções ativas, precisamos ajustar cada situação para sua realidade. Você precisa ter em mente qual é o maior tráfego que pode atingir por um IP da sua rede (seu maior plano) com base nisso tenha em mente que a cada 100MB gera em torno de 10.000 pps por segundo, isso não é regra mas pode ser uma base inicial. Vamos imaginar então que meu maior plano seja 900MB, farei uma ajuste no threshold_pps para 110.000 pps para não pegar alguma rajada inicial. Mas vale lembrar que inicialmente você precisa estudar sua rede e adaptar a sua realidade.

# sed -i 's/threshold_pps = 20000/threshold_pps = 110000/' /etc/fastnetmon.conf
# sed -i 's/threshold_tcp_pps = 100000/threshold_tcp_pps = 90000/' /etc/fastnetmon.conf
# sed -i 's/threshold_udp_pps = 100000/threshold_udp_pps = 90000/' /etc/fastnetmon.conf

Agora em threshold_mbps seria o maior tráfego que você irá permitir, eu normalmente não altero e deixo no padrão 1gb. E em threshold_flows o fluxos de limite qual também mantenho o mesmo valor 3500.

# sed -i 's/threshold_mbps = 1000/threshold_mbps = 999/' /etc/fastnetmon.conf
# sed -i 's/threshold_tcp_mbps = 100000/threshold_tcp_mbps = 900/' /etc/fastnetmon.conf
# sed -i 's/threshold_udp_mbps = 100000/threshold_udp_mbps = 900/' /etc/fastnetmon.conf

Ajustes de ICMP

# sed -i 's/threshold_icmp_mbps = 100000/threshold_icmp_mbps = 100/' /etc/fastnetmon.conf
# sed -i 's/threshold_icmp_pps = 100000/threshold_icmp_pps = 10000/' /etc/fastnetmon.conf

O netflow ouve a porta padrão 2055 se desejar alterar basta alterar o valor de netflow_port. Irei alterar para 52055.

# sed -i 's/netflow_port = 2055/netflow_port = 52055/' /etc/fastnetmon.conf

Ainda em /etc/fastnetmon.conf temos notify_script_path que sempre que o fastnetmon identificar um ataque irá executar o script /usr/local/bin/notify_about_attack.sh, identificando o IP da sua rede que está sofrendo (incoming) o ataque ou que está atacando (outgoing) alguém. Ele NÃO irá identificar os IPs de origem, pois em um ataque quase sempre as origens são alteradas por milhares de IPs aleatórios.

Faça alguns ajustes nos parâmetros do kernel

# vim /etc/sysctl.conf

Adicione ao final do arquivo, observe enp0s3 é o nome da sua interface de rede coloque o nome da sua, pode usar o comando ip addr para visualizar

net.ipv4.ip_forward = 1
net.ipv4.conf.all.rp_filter = 0
net.ipv4.conf.default.rp_filter = 0
net.ipv4.conf.lo.rp_filter = 0
net.ipv4.conf.enp0s3.rp_filter = 0

Carregue as alterações:

# sysctl -p

Habilite e reinicie o fastnetmon para carregar as novas configurações.

# systemctl enable fastnetmon
# systemctl restart fastnetmon

Verifique se a porta 52055/udp esta ouvindo:

# netstat -putan  | grep 52055

udp        0      0 0.0.0.0:52055           0.0.0.0:*                           2522/fastnetmon     

Bom mas antes de criarmos nosso script notify_about_attack.sh, precisamos preparar algumas coisas, e antes de mais nada vamos configurar nosso Huawei para enviar os dados.

Roteador RuterOS/Mikrotik:
Informe apenas suas interfaces de upstream (operadoras) ex: spf1,sfp1.100

RouterOS# /ip traffic-flow set active-flow-timeout=5s cache-entries=1k inactive-flow-timeout=1s interfaces=spf1,sfp1.100
RouterOS# /ip traffic-flow target add dst-address=10.52.52.2 v9-template-refresh=5 v9-template-timeout=1s

Roteador Huawei:

<HUAWEI> system-view
[~HUAWEI] ip netstream export version ipfix peer-as bgp-nexthop ttl
[*HUAWEI] ip netstream export template sequence-number fixed
[*HUAWEI] ip netstream export index-switch 32
[*HUAWEI] ip netstream as-mode 32
[*HUAWEI] ip netstream timeout active 1
[*HUAWEI] ip netstream timeout inactive 15
[*HUAWEI] ip netstream export template timeout-rate 1
[*HUAWEI] ip netstream export template option sampler
[*HUAWEI] ip netstream export template option application-label
[*HUAWEI] ip netstream sampler fix-packets 1024 inbound
[*HUAWEI] ip netstream sampler fix-packets 1024 outbound
[*HUAWEI] ip netstream export source 10.52.52.1
[*HUAWEI] ip netstream export host 10.52.52.2 52055

slot 0 NE8000F1A / slot 10 ou 9 NE8000 M8 / slot 3 NE40

[*HUAWEI] slot <0-10>
[*HUAWEI] ip netstream sampler to slot self
[*HUAWEI]  ipv6 netstream sampler to slot self

Será necessário adicionar em todas suas interfaces de Uplink:

 ip netstream inbound
 ip netstream outbound

Exemplo:

interface 40GE0/1/49.71
 vlan-type dot1q 71
 description BruxaDo71Telecom
 ip address 71.71.71.2 255.255.255.252
 statistic enable
 ip netstream inbound
 ip netstream outbound

Com o tcpdump vamos monitorar a interface para ver o que esta chegando na porta.

# tcpdump -i enp0s3 -n udp port 52055 -T cnfp -c 10

Se seu NE estiver mandado os pacotes você terá um resultado como:

tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on ens192, link-type EN10MB (Ethernet), capture size 262144 bytes
14:25:19.601113 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.608068 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.668054 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.691123 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.768055 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.781129 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.831133 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.858054 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.941124 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
14:25:19.958060 IP 10.52.52.1.40000 > 10.52.52.2.52055: NetFlow v9
10 packets captured
10 packets received by filter
0 packets dropped by kernel

Agora com o comando:

# fastnetmon_client

Iremos visualizar os TOP IPs

FastNetMon 1.1.3 master git- Pavel Odintsov: stableit.ru
IPs ordered by: packets
Incoming traffic       724347 pps   6998 mbps    161 flows
72.72.72.238            51973 pps    569 mbps      0 flows  *banned*
72.72.72.112            14390 pps    154 mbps      0 flows
72.72.72.93             14000 pps    150 mbps      0 flows
72.72.72.161            11705 pps    129 mbps      0 flows
72.72.72.118             8797 pps     86 mbps      0 flows
72.72.72.43              7602 pps     84 mbps      0 flows
72.72.72.111             6669 pps     64 mbps      0 flows

Outgoing traffic       291008 pps    705 mbps    101 flows
72.72.72.238            18009 pps     14 mbps      0 flows  *banned*
72.72.72.112             7929 pps      5 mbps      0 flows
72.72.72.93              7110 pps     10 mbps      0 flows
72.72.72.14              4910 pps     40 mbps      0 flows
72.72.72.43              4887 pps      2 mbps      0 flows
72.72.72.161             4537 pps      2 mbps      0 flows
72.72.72.111             3933 pps     14 mbps      0 flows

Internal traffic             0 pps      0 mbps

Other traffic              420 pps      0 mbps

Screen updated in:              0 sec 331 microseconds
Traffic calculated in:          0 sec 854 microseconds
Total amount of IPv6 packets related to our own network: 0
Not processed packets: 0 pps 

Subnet load:
72.72.72.0/22      pps in: 256000   out: 52000    mbps in: 9630  out: 1077
100.100.0.6/32     pps in: 0        out: 0        mbps in: 0     out: 0

Perceba que o IP 72.72.72.238 foi banido, pois o mesmo excedeu os pps de 50.000, no entanto este é um dos IPs que então em meu CGNAT, e vai ser natural este ter um comportamento diferente. Para que o fastnetmon ignore o mesmo você pode cria uma lista branca. Não se preocupe se isso acontecer com você o fastnetmon não ira fazer nenhuma ação, pois não configuramos nada ainda.
Para criar a lista branca networks_whitelist com os IPs ou prefixo que deseja ignorar.

# vim /etc/networks_whitelist

Exemplo

72.72.72.224/28
72.72.73.224/28

Reinicie para carregar as novas configurações.

# systemctl restart fastnetmon

Bot Telegram

Para receber notificações pelo Telegram juntamente com o arquivo de log, vai ser necessário criar um bot do telegram para o uso do mesmo. Se você não sabe como criar um Bot para telegram basta você falar com o @BotFather e enviar para ele /newbot, ele irá pedir qual nome você gostaria de dar a seu bot, e em seguida ira gera um token que vamos precisar a seguir.

Para o Telegram vamos usar um scriptzinho que criei.

# cd /tmp/
# wget https://github.com/remontti/TelegramCMD/archive/master.zip
# unzip /tmp/master.zip
# chmod a+x /tmp/TelegramCMD-master/telegram
# mv /tmp/TelegramCMD-master/telegram* /usr/local/bin/
# ln -s /usr/local/bin/telegram /bin/telegram

Edite o token.conf e altere para o seu TOKEN.

# vim /usr/local/bin/telegram.conf/token.conf

######################################
# Telegram bot                       #
# Create a new bot with @BotFather   #
# get TOKEN                          #
######################################

TOKEN="123456789:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

Esse script você pode usar para diversas coisas, ele será capaz de zipar um diretorio e lhe enviar o arquivo bem como enviar apenas uma mensagem. Como usar? É importante você saber que o IDs de grupos tem um “-” no inicio do ID, já usuários não. Para descobrir o ID do seu usuário fale com o bot @myidbot e envie para ele /getid, para saber de um grupo adicione @myidbot ao seu grupo e envie /getgroupid@myidbot. Realize um teste com um dos comandos: (Não esqueça de alterar pelo seu ID)

Uso: telegram [Opções]
  -m: Para enviar uma mensagem
     ex: telegram -m "ID Chat" "Meu assunto" "Minha mensagem..."
     ex: telegram -m "-123456789" "Notificação" "Mensagem para um grupo ID"
     ex: telegram -m "123456789" "Notificação" "Mensagem para direta/privado"

  -f: Para enviar um arquivo
     ex: telegram -f "ID Chat" "/diretorio/arquivo" "nome do arquivo zip" "Comentário"
     ex: telegram -f "12345689" /var/log/syslog syslog "Logs do sistema para user privado"
     ex: telegram -f "-12345689" /var/log/syslog syslog "Logs do sistema para um grupo"

  -t: Para enviar um arquivo sem compactar
     ex: telegram -f "ID Chat" "/diretorio/arquivo.txt" "Mensagem"
     ex: telegram -f "-12345689" /var/log/fastnetmon.log "Logs do sistema"

FRR

Vamos realizar a instalação do FRRouting (FRR) para fechar sessão BGP entre o roteador de borda e servidor.

# apt install frr frr-doc

Ative o modulo BGP

# sed -i 's/bgpd=no/bgpd=yes/' /etc/frr/daemons

Reinicie o FRR

# systemctl restart frr

Entre no shell VTY do FRR.

# vtysh

Rode o comando: `show running-config`

Hello, this is FRRouting (version 8.4.2).
Copyright 1996-2005 Kunihiro Ishiguro, et al.

fastnetmon#  show running-config 
Building configuration...

Current configuration:
!
frr version 8.4.2
frr defaults traditional
hostname fastnetmon
log syslog informational
no ipv6 forwarding
service integrated-vtysh-config
!
end

Agora entre no modo de configuração, e vamos preparar nosso peer com o router de borda. No exemplo está praticamente auto explicativo, vamos fechar o peer e deixar ser anunciado apenas nossos prefixos e aplicaremos a community 65001:666 para prefixos /32 e 65001:777 para prefixos /24

configure terminal
!
ip prefix-list FASTNETMON_EXPORT_32 seq 5 permit 72.72.72.0/22 le 32
!
ip prefix-list FASTNETMON_EXPORT_24 seq 5 permit 72.72.72.0/22 le 24
!
route-map MARK_FASTNETMON_IMPORT deny 10
exit
!
route-map MARK_FASTNETMON_EXPORT permit 10
 match ip address prefix-list FASTNETMON_EXPORT_24
 set community 65001:777
exit
! 
route-map MARK_FASTNETMON_EXPORT permit 20
 match ip address prefix-list FASTNETMON_EXPORT_32
 set community 65001:666
exit

!
router bgp 260072
 bgp router-id 10.52.52.2
 neighbor 10.52.52.1 remote-as 260072
 neighbor 10.52.52.1 description "BORDA"
 !
 address-family ipv4 unicast
  neighbor 10.52.52.1 route-map MARK_FASTNETMON_IMPORT in
  neighbor 10.52.52.1 route-map MARK_FASTNETMON_EXPORT out
 exit-address-family
exit
!
end
write memory
exit

Configuração RouterOS/Mikrotik

Crie um filtro de entrada que todas as rotas /32 e /24 aprendida do fastnetmon seja setadas como blackhole ou como prefixo para mitigação, e não ensine nada para ele.

/routing filter
add action=accept chain=FASTNETMON_IMPORT_IPV4 prefix-length=32 \
 set-bgp-communities=65444:666 set-distance=1 set-type=blackhole
add action=accept chain=FASTNETMON_IMPORT_IPV4 prefix-length=24 \
 set-bgp-communities=65444:777 set-distance=1 set-type=blackhole
add action=discard chain=FASTNETMON_IMPORT_IPV4
add action=discard chain=FASTNETMON_EXPORT_IPV4

Atenção para a instance que deve estar selecionada corretamente (use a mesma que você usa com sua operadora).

/routing bgp peer add name=FASTNETMON remote-as=260072 \
 in-filter=FASTNETMON_IMPORT_IPV4 out-filter=FASTNETMON_EXPORT_IPV4 \
 remote-address=10.52.52.2 update-source=10.52.52.1

Exemplo de configuração para filtro para operadora

/routing filter
add action=accept bgp-communities=65444:666 \
 chain=OPERADORA_IPv4_EXPORT prefix-length=32 set-bgp-communities=71:666
add action=accept chain=OPERADORA_IPv4_EXPORT \
 prefix=72.72.72.0/22 prefix-length=22-24 set-bgp-communities=""
add action=discard chain=OPERADORA_IPv4_EXPORT

Exemplo de configuração para filtro para mitigação

/routing filter
add action=accept bgp-communities=65444:777 \
 chain=MITIGACAO_IPv4_EXPORT prefix=72.72.72.0/22 \
 prefix-length=24 set-bgp-communities=19000:666
add action=discard chain=MITIGACAO_IPv4_EXPORT

Configurações do Huawei

<HUAWEI> system-view
Enter system view, return user view with return command.

Crie uma rota estática de Blackhole

[~HUAWEI] ip route-static 192.0.2.1 255.255.255.255 NULL0 description BLACKHOLE

Crie um filtro que irá aceitar qualquer rota /32

[*HUAWEI] ip ip-prefix  ACCEP_PREFIX_MASK32_FASTNETMON_IPV4 index 10 permit 0.0.0.0 0 greater-equal 32

Crie um filtro que irá aceitar as rota /24 de seu prefixo

[*HUAWEI] ip ip-prefix  ACCEP_PREFIX_MASK24_FASTNETMON_IPV4 index 10 permit 72.72.72.0 22 greater-equal 24

Crie filtro se desejar rejeitar algum IP ou prefixo atacado atacado, caso você deixar o fastnetmon anúnciar seu NE pode rejeitar (Ex IP Servidores ou CGNAT)

[*HUAWEI] ip ip-prefix  IGNORE_PREFIX_FASTNETMON_IPV4 index 10 permit 72.72.72.224 28 greater-equal 28 less-equal 32
[*HUAWEI] ip ip-prefix  IGNORE_PREFIX_FASTNETMON_IPV4 index 20 permit 72.72.73.224 28 greater-equal 28 less-equal 32

Crie um filtro para nossas community 65001:666 65001:777

[*HUAWEI] ip community-filter basic COMM_FASTNETMON_BLACKHOLE_32 index 10 permit 65001:666
[*HUAWEI] ip community-filter basic COMM_FASTNETMON_BLACKHOLE_24 index 10 permit 65001:777

Defina community para usar nos RP das operadoras

[*HUAWEI] ip community-filter basic COMM_BLACKHOLE_32 index 10 permit 65444:666
[*HUAWEI] ip community-filter basic COMM_BLACKHOLE_24 index 10 permit 65444:777

Vamos montar agora nosso route policy de import (rotas que iremos receber). A 1ª é ignorar os prefixos IGNORE_PREFIX_FASTNETMON_IPV4

[*HUAWEI] route-policy FASTNETMON_IMPORT_IPV4 deny node 1000
[*HUAWEI]  if-match ip-prefix IGNORE_PREFIX_FASTNETMON_IPV4

A 2º é o que vir marcado do fastnetmon com 65001:666 (COMM_FASTNETMON_BLACKHOLE_32) jogar para blackhole e aplicar uma community nova 65444:666, como no exemplo aqui meu AS é de 32bits vou usar um AS privado, mas onde seu AS é de 16bits o mais comunity de se encontrar é AS:666. Assim se você for trânsito de outro AS você pode montar em suas route policy para aceitar prefixos do AS dele com /32 marcados com AS:666 e jogar para blackhole também fica dica!

[*HUAWEI] route-policy FASTNETMON_IMPORT_IPV4 permit node 1010
[*HUAWEI]  if-match community-filter COMM_FASTNETMON_BLACKHOLE_32
[*HUAWEI]  apply local-preference 999
[*HUAWEI]  apply ip-address next-hop 192.0.2.1
[*HUAWEI]  apply community 65444:666
[*HUAWEI]  if-match ip-prefix ACCEP_PREFIX_MASK32_FASTNETMON_IPV4

Vamos preparar também para receber os prefixos /24 caso for anunciar para um mitigação por exemplo.

[*HUAWEI] route-policy FASTNETMON_IMPORT_IPV4 permit node 1020
[*HUAWEI]  if-match community-filter COMM_FASTNETMON_BLACKHOLE_24
[*HUAWEI]  apply local-preference 999
[*HUAWEI]  apply ip-address next-hop 192.0.2.1
[*HUAWEI]  apply community 65444:777
[*HUAWEI]  if-match ip-prefix ACCEP_PREFIX_MASK24_FASTNETMON_IPV4

E a 3ª ignoramos o resto como boas praticas.

[*HUAWEI] route-policy FASTNETMON_IMPORT_IPV4 deny node 9999

Para as route policy de export (Rotas que o NE irá ensinar) colocarei apenas um Deny pois ele não precisa ensinar nada.

[*HUAWEI] route-policy FASTNETMON_EXPORT_IPV4 deny node 9999
[*HUAWEI] commit

Vamos ao peer

[~HUAWEI] bgp 260072
[~HUAWEI] undo peer 10.52.52.2
[*HUAWEI]  peer 10.52.52.2 as-number 260072
[*HUAWEI]  peer 10.52.52.2 description BORDA_VS_FASTNETMON_IPV4
[*HUAWEI]  peer 10.52.52.2 timer connect-retry 1
[*HUAWEI]  peer 10.52.52.2 connect-interface 10.52.52.1
[*HUAWEI]  peer 10.52.52.2 timer keepalive 10 hold 30 
           y
[*HUAWEI]  ipv4-family unicast
[*HUAWEI]   peer 10.52.52.2 enable
            y
[*HUAWEI]   peer 10.52.52.2 public-as-only
[*HUAWEI]   peer 10.52.52.2 route-policy FASTNETMON_IMPORT_IPV4 import
[*HUAWEI]   peer 10.52.52.2 route-policy FASTNETMON_EXPORT_IPV4 export
[*HUAWEI]   peer 10.52.52.2 next-hop-local
[*HUAWEI]   peer 10.52.52.2 advertise-community
[*HUAWEI]   peer 10.52.52.2 advertise-ext-community
[*HUAWEI] commit
[~HUAWEI] run save 

Em caso de alguma emergência, para baixar a sessão use:

[~HUAWEI] bgp 260072
[*HUAWEI] peer 10.52.52.2 ignore
[*HUAWEI] commit

Para subir novamente:

[~HUAWEI] bgp 260072
[*HUAWEI] undo peer 10.52.52.2 ignore
[*HUAWEI] commit

Verifique se sua sessão subiu:

[*HUAWEI] display bgp peer | include 10.52.52.2

 BGP local router ID : x.x.x.x
 Local AS number : 260072
 Total number of peers : 13                 Peers in established state : 13

  Peer                             V          AS  MsgRcvd  MsgSent  OutQ  Up/Down       State  PrefRcv
  10.52.52.2                       4       260072   897801  1088107     0 2496h26m Established        0

No FRR use `show bgp summary`

# vtysh

# show bgp summary
IPv4 Unicast Summary:
BGP router identifier 10.52.52.2, local AS number 260072 vrf-id 0
BGP table version 0
RIB entries 0, using 0 bytes of memory
Peers 1, using 21 KiB of memory

Neighbor        V         AS   MsgRcvd   MsgSent   TblVer  InQ OutQ  Up/Down State/PfxRcd   PfxSnt
10.52.52.1      4     260072         5         5        0    0    0 00:02:52            0        0

Total number of neighbors 1
# exit

Para repassar os prefixos marcados como blackhole para sua operadora você precisará saber qual é a community que a mesma utiliza e se ela lhe oferece esse recurso, em seguida você irá adicionar a route policy da sua operadora uma nova regra:

No exemplo tudo que recebemos do fastnetmon passamos a aplicar a community 65444:666, logo tudo que for marcado com a mesma iremos repassar para operadora, com o community da operadora.

[~HUAWEI] route-policy UPSTREAM_OP_BRUXADO71_EXPORT_IPV4 permit node 2070
[*HUAWEI]  if-match community-filter COMM_BLACKHOLE_32
[*HUAWEI]  apply community 71:666

Agora tudo que marcamos com community 65444:777 enviamos para mitigraçação

[*HUAWEI] route-policy UPSTREAM_MITIGAAI_EXPORT_IPV4 permit node 2070
[*HUAWEI]  if-match community-filter COMM_BLACKHOLE_24
[*HUAWEI]  apply community 1000:9999

Pronto agora que já temos nosso peer Up entre router e servidor, nosso Bot mandando mensagem, iremos criar o script que será executado sempre que um ataque for identificado BAN ou UNBAN. Irei criar um diretório /var/log/fastnetmon_attacks/ataques qual irá ficar os ataques finalizados.

# mkdir /var/log/fastnetmon_attacks/ataques -p
# vim /usr/local/bin/notify_about_attack.sh

Altere ID_CHAT=’-1000000000000′ pelo ID do seu usuário ou grupo.
Para anunciar os prefixos /24 do IP atacado altere ANUNCIAR_24 para sim
Se não quiser receber o arquivo de log altere ARQUIVO_DE_LOG para nao
Dei uma encrementada para identificar a categoria do IP, que iremos ver em seguido o script que ira identificar, em IDENT_CATEGORIA vai poder classificar exemplo se um ip é de CGNAT, servidor…

#!/usr/bin/env bash
#
# Este script receberá os seguintes parâmetros:
# $1 IP do cliente
# $2 INCOMING -> Vindo de fora da rede | OUTGOING -> Saindo da sua rede
# $3 Pacotes por seguncoes
# $4 Ação (ban ou unban)
#
#--------------------------------------------------------------------------------
# Defina o ID do Chat ou Grupo  do Telegram (Grupos sempre começam com "-" )
ID_CHAT='-1000000000000'
#
# Deseja anunciar prefixos /24? (sim/nao)
ANUNCIAR_24='nao'
#
# Deseja enviar arquivo de log compactado para o telegram? (sim/nao)
ARQUIVO_DE_LOG='sim'
#
# Deseja identificar a categoria do endereço atacado (sim/nao)
# script python /opt/rr_fastnetmon/prefixos.txt
IDENT_CATEGORIA='sim'
#
# Seu ASN
ASN=260072
#--------------------------------------------------------------------------------
#
# Pegando prefixo 24
ip32=$1
prefixo24="${ip32%.*}.0/24"
#
quebralinha="
"
#
if [ "$2" = "incoming" ]; then
  TIPO="Sendo atacado"
else
  TIPO="Realizando um ataque"
fi
#
if [ "$IDENT_CATEGORIA" = "sim" ]; then
  CATEGORIA=$(/opt/rr_fastnetmon/categoria_ip.py $1)
else
  CATEGORIA=""
fi
#
# Desbanindo um IP
if [ "$4" = "unban" ]; then
  # Remove IP do anuncio para o FRR
  if [ $ANUNCIAR_24 = "sim" ]; then
    /usr/local/bin/telegram -m "$ID_CHAT" "<b>(UNBAN) Anúncios removido</b>" "<code> Blackhole: $1/32$quebralinha Prefixo: $prefixo24</code>"
    vtysh --command "configure terminal
    no ip route $1/32 lo
    no ip route $prefixo24 lo
    router bgp $ASN
     address-family ipv4 unicast
      no network $1/32
      no network $prefixo24
    "
  else
    /usr/local/bin/telegram -m "$ID_CHAT" "<b>(UNBAN) Anúncio removido</b>" "<code> Blackhole: $1/32$quebralinha</code>"
    vtysh --command "configure terminal
    no ip route $1/32 lo
    router bgp $ASN
     address-family ipv4 unicast
      no network $1/32
    "
  fi
  # Movemos os logs para pasta ataques pois não queremos mais receber elas.
  mv /var/log/fastnetmon_attacks/$1* /var/log/fastnetmon_attacks/ataques
  exit 0
fi
#
# Banindo um IP
if [ "$4" = "ban" ]; then
  cp /var/log/fastnetmon_attacks/$1* /var/log/fastnetmon_attacks/$1.log.txt &>/dev/null
  # Anuncia IP ao FRR
  if [ $ANUNCIAR_24 = "sim" ]; then
    /usr/local/bin/telegram -m "$ID_CHAT" "<b>(BAN) $TIPO</b> [ $3 pps ]" "Anunciando$quebralinha<code> Blackhole: $1/32$quebralinha Prefixo: $prefixo24</code>$quebralinha <i>$CATEGORIA</i>"
    vtysh --command "configure terminal
    ip route $1/32 lo
    ip route $prefixo24 lo
    router bgp $ASN
     address-family ipv4 unicast
      network $1/32
      network $prefixo24
    "
  else
    /usr/local/bin/telegram -m "$ID_CHAT" "<b>(BAN) $TIPO</b> [ $3 pps ]" "Anunciando$quebralinha<code> Blackhole: $1/32</code>$quebralinha <i>$CATEGORIA</i>"
    vtysh --command "configure terminal
    ip route $1/32 lo
    router bgp $ASN
     address-family ipv4 unicast
      network $1/32
    "
  fi
  # Envio de log
  if [ $ARQUIVO_DE_LOG = "sim" ]; then
    /usr/local/bin/telegram -t "$ID_CHAT" /var/log/fastnetmon_attacks/$1.log.txt "Logs do ataque"
  fi
  sleep 2
  rm /var/log/fastnetmon_attacks/$1.log.txt &>/dev/null
  exit 0
fi
#
if [ "$4" == "attack_details" ]; then
  # Null
  exit 0
fi

De permissão para execução

# chmod a+x /usr/local/bin/notify_about_attack.sh

Crie um diretório em /opt/rr_fastnetmon onde iremos colocar nossos scripts complementares

# mkdir /opt/rr_fastnetmon

Crie o arquivo categoria_ip.py que utiliza python3 (Não se preocupe em instalar o python)

# vim /opt/rr_fastnetmon/categoria_ip.py

Adicione:

#!/usr/bin/env python3

import sys
import ipaddress

if len(sys.argv) != 2:
    print("Uso: categoria_ip.py <endereço IP>")
    sys.exit(1)

ip = sys.argv[1]

# Converter o endereço IP fornecido em um objeto ipaddress.IPv4Address
endereco_ip = ipaddress.IPv4Address(ip)

# Procurar a categoria correspondente ao endereço IP no arquivo prefixos.txt
categoria = None

with open("/opt/rr_fastnetmon/prefixos.txt") as arquivo:
    for linha in arquivo:
        prefixo, cat = linha.strip().split(" ")
        rede = ipaddress.IPv4Network(prefixo)
        if endereco_ip in rede:
            categoria = cat
            break

if categoria is None:
    print("Categoria não encontrada para o endereço IP")
else:
    print("Categoria:", categoria)

# chmod +x /opt/rr_fastnetmon/categoria_ip.py

Agora crie um arquivo prefixos.txt nele você pode classificar seus IPs assim no alarme ira lhe ajudar (ou você pode invetar algo novo). Coloque sempre os mais especificos primeiro caso você não queira declarar todos os prefixos.

# vim /opt/rr_fastnetmon/prefixos.txt

Exemplo:

72.72.72.0/26 Servidor
72.72.72.128/26 CGNAT
72.72.73.0/24 Cliente_Dedicado
72.72.72.0/22 Clientes_Dinamico

Teste o script executando como no exemplo:

# /opt/rr_fastnetmon/categoria_ip.py 72.72.72.20
Categoria: Servidor

# /opt/rr_fastnetmon/categoria_ip.py 72.72.72.140
Categoria: CGNAT

# /opt/rr_fastnetmon/categoria_ip.py 72.72.73.100
Categoria: Cliente_Dedicado

# /opt/rr_fastnetmon/categoria_ip.py 72.72.72.80
Categoria: Clientes_Dinamico

# /opt/rr_fastnetmon/categoria_ip.py 72.72.75.9
Categoria: Clientes_Dinamico

Exemplo de alarme no telegram

Restarte o fastnetmon

# systemctl restart fastnetmon

Se quiser fazer um teste manual simulando um anuncio de um IP (Cuidado se estiver anunciando prefixo) exemplo: 72.72.73.255/32

 # /usr/local/bin/notify_about_attack.sh 72.72.73.255 incoming 9996 ban

Verificando se esta enviando:

# vtysh --command " show ip bgp neighbors 10.52.52.1 advertised-routes"

BGP table version is 3, local router ID is 10.52.52.2, vrf id 0
Default local pref 100, local AS 260072
Status codes:  s suppressed, d damped, h history, * valid, > best, = multipath,
               i internal, r RIB-failure, S Stale, R Removed
Nexthop codes: @NNN nexthop's vrf id, < announce-nh-self
Origin codes:  i - IGP, e - EGP, ? - incomplete
RPKI validation codes: V valid, I invalid, N Not found

   Network          Next Hop            Metric LocPrf Weight Path
*> 72.72.73.255/32  0.0.0.0                  0         32768 i

Total number of prefixes 1

Para remover:

 # /usr/local/bin/notify_about_attack.sh 72.72.73.255 incoming 9996 unban

Finalizamos a primeira parte sem fazer nenhum estrago ao servidor (CPU)

Seria interessante fazer alguns testes de ataques (coisa pequena) mas com características reais de dentro da sua rede e de fora, escolha uma IP que não esteja em uso para tal! Para realizar esse ataque user o a ferramenta criada pelo ekovegeance: https://github.com/ekovegeance/DDOS Cuidado você pode criar um alto uso de Hardware na sua rede!!!

Em um servidor/desktop linux vai precisar ter instalado os pacotes bash sudo curl netcat hping3 openssl stunnel nmap whois dnsutils.
Baixe os arquivos, extraia entre em sua pasta e execute o arquivo ddos.

$ wget https://github.com/ekovegeance/DDOS/archive/v1.2.4.zip
$ unzip v1.2.4.zip 
$ cd DDOS-1.2.4/
$ ./ddos

Gráficos Grafana

Habilite o graphite no fastnetmon

# sed -i 's/graphite = off/graphite = on/' /etc/fastnetmon.conf

Vamos instalar o influxdb para ser a base de dados

# apt install gnupg2 -y
# cd /tmp
# wget -q https://repos.influxdata.com/influxdata-archive_compat.key
# echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' \
  | sha256sum -c && cat influxdata-archive_compat.key \
  | gpg --dearmor \
  | tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null
# echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main'\
  | tee /etc/apt/sources.list.d/influxdata.list
# apt update
# apt install influxdb -y

Crie uma cópia do arquivo de configuração, e edite o mesmo

# cp /etc/influxdb/influxdb.conf /etc/influxdb/influxdb.conf.orig
# vim /etc/influxdb/influxdb.conf

Localize [[graphite]] e insira a baixo as seguintes linhas:

[[graphite]]
  enabled = true
  bind-address = ":2003"
  protocol = "tcp"
  consistency-level = "one"
  separator = "."
  templates = [
    "fastnetmon.hosts.* app.measurement.cidr.direction.function.resource",
    "fastnetmon.networks.* app.measurement.cidr.direction.resource",
    "fastnetmon.total.* app.measurement.direction.resource"
  ]

Reinicie o influxdb

# systemctl restart influxdb

Em seguida o fastnetmon

# systemctl restart fastnetmon

Agora vamos acessar o o influxdb para ver se o banco e verificar se o graphite foi criado.

# influx

Connected to http://localhost:8086 version 1.8.10
InfluxDB shell version: 1.8.10

> SHOW databases

name: databases
name
----
_internal
graphite

> USE graphite

Using database graphite

> SHOW MEASUREMENTS

name: measurements
name
----
hosts
networks
total

Se você tem pouco disco e deseja não salvar por tanto tempo, você pode ajustar o tempo de retenção dos dados, no comando estarei informando 90 dias (padrão é infinito) com métrica de tráfego para 7 dias (padrão ja é 7 dias), será necessário apagar o banco e recria-lo.

> SHOW RETENTION POLICIES ON graphite

name    duration shardGroupDuration replicaN default
----    -------- ------------------ -------- -------
autogen 0s       168h0m0s           1        true

Vamos remover o banco, criar novamente com os tempos desejados

> DROP DATABASE graphite
> CREATE DATABASE graphite WITH DURATION 90d SHARD DURATION 7d
> SHOW RETENTION POLICIES ON graphite

name    duration  shardGroupDuration replicaN default
----    --------- ------------------ -------- -------
autogen 2160h0m0s 168h0m0s           1        true

> exit

Reinicie os serviços novamente

# systemctl restart influxdb fastnetmon

Você pode optar pelo modo bruto e remover com script.

# vim /root/limpa_graphite.sh

Ajuste o número de dias que deseja que fique salvo apenas.

#!/bin/bash

# Manter por quantos dias?
DIAS="7"

# Define o banco de dados
DATABASE="graphite"

# Define os comandos
COMMANDS=("DELETE FROM hosts WHERE time < now() - ${DIAS}d" "DELETE FROM networks WHERE time < now() - ${DIAS}d" "DELETE FROM total WHERE time < now() - ${DIAS}d")

# Executa cada comando
for cmd in "${COMMANDS[@]}"; do
    echo "Executing: $cmd"
    influx -database "$DATABASE" -execute "$cmd"
done

echo "Todos os comandos executados com sucesso"

De permissão e execute, se desejar pode adicionar ao cron:

# chmod +x /root/limpa_graphite.sh
# /root/limpa_graphite.sh

Grafana

Adicione o repositório do grafana e instale-o

# wget -q -O /usr/share/keyrings/grafana.key https://apt.grafana.com/gpg.key
# echo "deb [signed-by=/usr/share/keyrings/grafana.key] https://apt.grafana.com stable main" | tee -a /etc/apt/sources.list.d/grafana.list
# apt update; apt install grafana -y

Habilite serviço para inicialização e inicie o mesmo

# systemctl enable grafana-server
# systemctl start grafana-server

Acesse em seu navegador http://ip_privado:3000 e entre com usuário e senha admin em seguida defina uma nova senha. Atualmente o grafana esta na versão 9.5.x caso você instale uma versão superior no futuro os passos não devem mudarem muito de locais.

No menu vá em Connections, clique em Connect data

Localize influxDB e clique nele

Preencha apenas:
URL: http://localhost:8086
Database: graphite
E clique em Save & test, você deve ter a resposta atasource is working. 3 measurements found.
Mas antes de sair anote o uid que esta na URL no meu caso: da56a879-9ae6-42ca-aeb5-236e8b439be4, vamos precisar dele para facilitar ao importar as dashs.

Faça download aqui das Dashs e importe.
- Fastnetmon - Home
- Fastnetmon - Painel Geral
- Fastnetmon - Top PPs
- Fastnetmon - Top Prefixos
- Fastnetmon - Top Hosts MBs
- Fastnetmon - Top Tráfego saída
- Fastnetmon - Tráfego por Prefixo
- Fastnetmon - Tráfego por endereço IPv4

Extraia o arquivo zip e abra em um editor de texto os arquivos .json localize xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx e substitua pelo seu uid, assim lhe poupará de fazer ajustes manuais.
Se seu desktop é um linux use o comando sed e faça em um unico comando:
`sed -i 's/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/da56a879-9ae6-42ca-aeb5-236e8b439be4/' *.json`

Volte para o menu e clique em Dashboards

Importe uma a um das Dashs.

Gostou? Se sentindo mais seguro agora? É consultor e ganha $ com isso!?

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.

Abraço!

Fontes:
https://fastnetmon.com/install/
https://docs.frrouting.org/en/latest/bgp.html
https://deb.frrouting.org/
https://fastnetmon.com/docs/influxdb_integration/
https://grafana.com/docs/grafana/latest/installation/debian/

O post Fortalecendo a Resiliência da Rede: Detecção de Ataques DDoS com FastNetMon, FRRouting, Grafana e Implementação em Debian 12 com Huawei & RouterOS apareceu primeiro em Remontti.

Neste tutorial vamos aprender a monitorar o status da sessão BGP no RouterOS v6 o nosso “querido” Mikrotik, bem como receber notificações se a sessão cair ou reconectar.

Como a mikrotik não disponibiliza essas informações via SNMP das sessões BGP, usaremos das artimanhas. Então juntamente com meu amigo Saulo Costa qual identificou que existe uma OID dos script que estão no RouterOS (1.3.6.1.4.1.14988.1.1.8.1.1.2) e outra (1.3.6.1.4.1.14988.1.1.18.1.1.2.***) que é possivel executar-lo bem como ter retornos, e ai meu amigo as mentes voaram longe!

Acompanhe o raciocínio:

1º Crie um script em seu RouterOS

Darei o nome do script de bgp_snmp

:put "{\"peer\": [";
:global lista [/routing bgp peer find];
:global contador 0;
:foreach i in=$lista do={
  :global disabled [/routing bgp peer get value-name=disabled number=$i];
  :global name [/routing bgp peer get value-name=name number=$i];
  :global remoteaddress [/routing bgp peer get value-name=remote-address number=$i];
  :global remoteas [/routing bgp peer get value-name=remote-as number=$i];
  :global state [/routing bgp peer get value-name=state number=$i];
    :if (state = "idle") do={:set state 1;};
    :if (state = "connect") do={:set state 2;}
    :if (state = "active") do={:set state 3;}; 
    :if (state = "opensent") do={:set state 4;}
    :if (state = "openconfirm") do={:set state 5;}; 
    :if (state = "established") do={:set state 6;}
    :if (disabled = true) do={:set state 1;}
  :global prefix [/routing bgp peer get value-name=prefix number=$i];
    :if (prefix < 1) do={:set prefix 0;}  
  :global uptime [/routing bgp peer get value-name=uptime number=$i];
    :if (uptime < 1) do={:set uptime 0;}
    :global uptimeseconds 0; :global weekend 0; 
    :global dayend 0; :global weeks 0; :global days 0;
    :if ([:find $uptime "w" -1] > 0) do={
      :set weekend [:find $uptime "w" -1];
      :set weeks [:pick $uptime 0 $weekend];
      :set weekend ($weekend+1);
    };
    :if ([:find $uptime "d" -1] > 0) do={
      :set dayend [:find $uptime "d" -1];
      :set days [:pick $uptime $weekend $dayend];
    };
    :global time [:pick $uptime ([:len $uptime]-8) [:len $uptime]]; 
    :global hours [:pick $time 0 2];
    :global minutes [:pick $time 3 5];
    :global seconds [:pick $time 6 8]; 
    :set uptimeseconds [($weeks*86400*7+$days*86400+$hours*3600+$minutes*60+$seconds)];

  :set contador ($contador + 1);
  :if ( $contador < [:len $lista]) do={
    :put "{\"Id\": \"$contador\",\"Disabled\": \"$disabled\",\"Name\": \"$name\",\"Remote-Address\": \"$remoteaddress\",\"Remote-AS\": \"$remoteas\",\"State\": \"$state\",\"Prefix\": \"$prefix\",\"Uptime\": \"$uptimeseconds\"},"
  } else={
    :put "{\"Id\": \"$contador\",\"Disabled\": \"$disabled\",\"Name\": \"$name\",\"Remote-Address\": \"$remoteaddress\",\"Remote-AS\": \"$remoteas\",\"State\": \"$state\",\"Prefix\": \"$prefix\",\"Uptime\": \"$uptimeseconds\"}"
  };
  };
:put "]}";

A idéa é pegar as informações no scrip e apenas imprimi-las. Experimente executar o script agora!

[user@mikrotik] > system script run bgp_snmp

Você terá uma saída em JSON com as informações que iremos coletar lá no Zabbix.

{"peer": [
{"Id": "1","Disabled": "false","Name": "VS_BORDA_IPv4","Remote-Address": "10.50.50.29","Remote-AS": "1234","State": "6","Prefix": "1","Uptime": "83235"},
{"Id": "2","Disabled": "false","Name": "VS_BORDA_IPv6","Remote-Address": "fd00:bacb:50:28::1","Remote-AS": "1234","State": "6","Prefix": "1","Uptime": "3500"}
]}

2º Configure o SNMP

Será necessário habiliar o write-access, então tenha certeza de ter uma community fora dos padrões (ex public {mando te matar!}) bem como restringir o acesso apenas para IP ou Prefixos de seus servidores.
Segue um exemplo:

/snmp community set [ find default=yes ] addresses=200.200.200.0/28 name=sUpErS3cret0 write-access=yes
/snmp set contact="noc@remontti.com.br" enabled=yes location="Seu Local" trap-version=2

3º Teste do seu servidor Zabbix

No exemplo meu router tem o IP 10.50.50.30 e minha community é sUpErS3cret0. Se você não tem as MIBS e o comando snmpwalk não "funciona" leia aqui.

# snmpwalk -v2c -c sUpErS3cret0 10.50.50.30 1.3.6.1.4.1.14988.1.1.8.1.1.2

Você tera um resultado com todos os seus scripts:

SNMPv2-SMI::enterprises.14988.1.1.8.1.1.2.1 = STRING: "bakup_ftp"
SNMPv2-SMI::enterprises.14988.1.1.8.1.1.2.4 = STRING: "script_da_morte"
SNMPv2-SMI::enterprises.14988.1.1.8.1.1.2.7 = STRING: "bgp_snmp"

O que é iportante para nós é esse numerozinho aqui: 14988.1.1.8.1.1.2.7, mais propriamente dito o final dele, neste exemplo o nº 7, este é o identificador do script. Anote ele, vamos precisar ele lá no nosso template.
Agora vamos rodar o script e fazer um get para ver se temos o retorno com o OID 1.3.6.1.4.1.14988.1.1.18.1.1.2.X. Onde X é o nº do identificador do script (neste ex 7).

# snmpget -v2c -c sUpErS3cret0 10.50.50.30 1.3.6.1.4.1.14988.1.1.18.1.1.2.7 |  sed -e 's/\\//g'

Você irá receber uma saída com todos os peers do seu router:

SNMPv2-SMI::enterprises.14988.1.1.18.1.1.2.8 = STRING: "{"peer": [
{"Id": "1","Disabled": "false","Name": "VS_BORDA_IPv4","Remote-Address": "10.50.50.29","Remote-AS": "1234","State": "6","Prefix": "1","Uptime": "84508"},
{"Id": "2","Disabled": "false","Name": "VS_BORDA_IPv6","Remote-Address": "fd00:bacb:50:28::1","Remote-AS": "1234","State": "6","Prefix": "1","Uptime": "4773"}
]}"

4º Importando o template para o Zabbix

Faça download do template RR Mikrotik - BGP - SNMP Script.xml e importe o mesmo.

5º Crie/Edite um host usando o template

Informe o Nome, grupo bem como IP com agente SNMP.

Selecione o template RR Mikrotik - BGP - SNMP Script

Lembra do identificador, precisamos informa-lo aqui.

Acesse os dados recentes para verificar se os itens foram criados (lembrado que ele é executado a cada 5min) então tenha paciência de aguardar 10min ou execute manualmente.

Bem mais simplique que o metodo do outro tutorial com script python.

Espero que tenha gostado! E mais uma vez deixo meu agradecimento ao parceio Saulo. Se fizer algo legal não deixe de compartilhar! Com isso você pode criar até mesmo outros templates, para coletar outras informações. Isso é o legal de compartilhar!

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 Monitorando no Zabbix as sessões BGP do RouterOS v6 (Mikrotik) via SNMP apareceu primeiro em Remontti.

Neste tutorial vamos aprender a monitorar o status da sessão BGP no RouterOS/Mikrotik, bem como receber notificações se a sessão cair ou reconectar.

PARA PARA PARA…. Quando escrevi este tutorial não existia esse tutorial aqui, recomendo você lêr ele, pois descobrimos outra forma mais simples.

Como a mikrotik não disponibiliza essas informações via SNMP (até o momento, esperaça de pobre é a ultima que morre) teremos que usar das artimanhas, então nosso amigo Gabriel Vargas Padilha fez um script em python mikrotikBgpZabbixScript para buscar as informações, eu montei a parte do Zabbix.

Se aida não tem o Zabbix instalado siga: Instalação do Zabbix 5 LTS + Grafana + NGINX + PostgreSQL + Telegram

Configuração

Requisitos:
– RouterOS 6.48 ou maior
– Zabbix Server 5.x
– Distribuição: Debian 10/11

Configuração no RouterOS/Mikrotik

Será necessário criar um usuário com permissões somente de leitura bem como restringindo o acesso para somente o IP do Zabbix, para fazer a conexão para coletas de dados.

/user add group=read address=IP_ZABBIX name=SEU_USUARIO password=SUA_SENHA

Se desejar desativar as infomação de login. Isso fará com que você não veja mais nenhum login feito no router.

/system logging set 0 topics=info,!account

OBS: Não use espaço e caracter especial nos nomes dos Peer’s e tenha nomes diferentes para cada Peer.

Zabbix Serve/Linux

Pacotes necessários:

# apt install python3-pip
# pip3 install librouteros

Acesse o diretório externalscripts e faça download.

# cd /usr/lib/zabbix/externalscripts/

Faça download dos scripts

# apt install wget 
# wget https://raw.githubusercontent.com/gtkpad/mikrotikBgpZabbixScript/main/main.py -O mikrotikBgp.py
# wget https://raw.githubusercontent.com/gtkpad/mikrotikBgpZabbixScript/main/Mikrotik.py

De permissão para os arquivos para execução e altere o dono para o usuário zabbix.

# touch mikrotikBgp.log 
# chmod +x mikrotikBgp.py 
# chown zabbix. mikrotikBgp.py Mikrotik.py mikrotikBgp.log 
# systemctl  restart zabbix-server

Informações de uso do script:

# ./mikrotikBgp.py <IP> <USER> <PASS> <API_PORT> <METHOD>
# ./mikrotikBgp.py <IP> <USER> <PASS> <API_PORT> <METHOD> <PEER_NAME>
# ./mikrotikBgp.py <IP> <USER> <PASS> <API_PORT> <METHOD> <PEER_NAME> <PEER_INFO>

METHOD’s
getPeer – Retorna todos os peerings em formato json.
getPeerInfo – Retorna o valor especifico de um peer.

Exemplos de uso:

# cd /usr/lib/zabbix/externalscripts
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeers

{
   "data":[
      {
         "{#PEER_NAME}":"VS_BORDA_IPV4",
         "{#PEER_AS}":12345,
         "{#PEER_ADDR}":"10.20.30.5"
      },
      {
         "{#PEER_NAME}":"VS_BORDA_IPV6",
         "{#PEER_AS}":12345,
         "{#PEER_ADDR}":"fd00:bacb:20:30::1"
      },
      {
         "{#PEER_NAME}":"NAT_PPPOES_IPV4",
         "{#PEER_AS}":65530,
         "{#PEER_ADDR}":"10.20.30.14"
      }
   ]
}

# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4 name
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4 instance
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4 remote-address
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4 remote-as
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4 uptime
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4 established
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4 prefix-count
# ./mikrotikBgp.py 10.20.30.40 usuario senha 8728 getPeerInfo VS_BORDA_IPV4 advertisements

Agora acesse seu Zabbix, e importe o Template:
Faça download do template RR Mikrotik – BGP – Script Python.xml e importe.

Crie um novo host, ou inclua o agent.

Selecione o Template RR Mikrotik – BGP – Script. Você encontra outros templates aqui também.

Por fim, herde os macros do template, e clique em modificar para informar os seus dados em seguida clique em salvar

OBS: A descoberta esta ajustada para 6h, se desejar que seja mais rápido execute manualmente, para realizar esse procedimento faça:

Grafana Modelo

Apenas uma idéia para você montar uma dash bacaninha:

Vou deixar aqui dash Modelo

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 Monitorando no Zabbix as sessões BGP do RouterOS/Mikrotik (Script Python) apareceu primeiro em Remontti.

Cliente TR-069 (Relatório Técnico 069) é uma implementação do CWMP (CPE WAN Management Protocol) para gerenciar dispositivos de usuários finais de forma centralizada. Este CWMP é executado em uma rede IP usando HTTP ou HTTPS para se comunicar com dispositivos ACS (Sistema de configuração automática), onde ACS é um sistema usado para monitorar, configurar e atualizar o firmware de dispositivos remotos.

Em geral, a função do TR-069 é mais amplamente usada em ISPs para gerenciamento de dispositivos do usuário final. Alguns dispositivos que estão atualmente começando a implementar as funções do TR-069, como FTTH CPE/ONT, WIMAX CPE, também podem ser usados ​​para monitoramento de VoIP ou CFTV. E no próprio MikroTik, a função Cliente TR-069 também foi adicionada a partir do RouterOS versão 6.38.

Requesitos:
Debian 11 Bullseye – Instalação Limpa

Leitura recomendada:
Configurando interface de rede no Debian 11
Como melhorar a produtividade no seu Debian após instalação

Ajustando o repositório

# vim /etc/apt/sources.list

Adicione contrib non-free aos repositórios

# deb http://YOUR_MIRROR/debian/ bullseye main contrib non-free
# deb-src http://YOUR_MIRROR/debian/ bullseye main contrib non-free

deb http://deb.debian.org/debian/ bullseye main contrib non-free
deb-src http://deb.debian.org/debian/ bullseye main contrib non-free

deb http://security.debian.org/debian-security bullseye-security main contrib non-free
deb-src http://security.debian.org/debian-security bullseye-security main contrib non-free

deb http://deb.debian.org/debian/ bullseye-updates main contrib non-free
deb-src http://deb.debian.org/debian/ bullseye-updates main contrib non-free

Atualize o repositório:

# apt update

Se tiver algum pacote para atualização também faça:

# apt upgrade -y

Intale os firmware-linux*

# apt install firmware-linux firmware-linux-free firmware-linux-nonfree -y

Reinicie seu servidor para carregar os novos módulos do kernel

# reboot

Pré-requisitos:
– Node.js
– MongoDB

https://genieacs.com
http://docs.genieacs.com/

# apt install curl gnupg2 wget

Instalção do Node.js

Repositório Node Js

# curl -fsSL https://deb.nodesource.com/setup_lts.x | bash -
# apt install nodejs -y

Verifique a versão

# npm -v

Veja se não tem atualização

# npm search -g npm

Exemplo colocando a para atualizar (Ajuste a versão)

# npm install -g npm@9.6.7

Instalação do MongoDB

Adicione o repositorio do MongoD (Sim é Buster Bullseye até o momento out/2021 não tem)

Versão 5 (Recomendada)

# cd /tmp
# echo "deb http://repo.mongodb.org/apt/debian buster/mongodb-org/5.0 main" | tee /etc/apt/sources.list.d/mongodb-org-5.0.list
# curl -sSL https://www.mongodb.org/static/pgp/server-5.0.asc  -o mongoserver.asc
# gpg --no-default-keyring --keyring ./mongo_key_temp.gpg --import ./mongoserver.asc
# gpg --no-default-keyring --keyring ./mongo_key_temp.gpg --export > ./mongoserver_key.gpg
# mv mongoserver_key.gpg /etc/apt/trusted.gpg.d/

Versão 4 (Alguns relatos que no vmware não teve jeito de fazer o mongodb iniciar e a v4 funcionou)

# cd /tmp
# echo "deb http://repo.mongodb.org/apt/debian buster/mongodb-org/4.4 main" | tee /etc/apt/sources.list.d/mongodb-org-4.4.list
# wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | apt-key add - 

Atualize o repositório e instale o mongodb bem como a estensão do nodejs

# apt update
# apt install mongodb-org node-mongodb

Ative o serviço para iniciar com o boot, inicie o serviço e verifique se o mesmo iniciou com êxito.

# systemctl enable mongod
# systemctl start mongod
# systemctl status mongod

Instalação do GenieACS

Procure se o pacote existe:

# npm search -g genieacs

NAME                      | DESCRIPTION          | AUTHOR          | DATE       | VERSION  | KEYWORDS       
genieacs                  | A TR-069 Auto…       | =zaidka         | 2022-08-22 | 1.2.9    | TR-069 CWMP ACS
@anlix-io/genieacs-sim    | TR-069 client…       | =anlix-io       | 2023-05-30 | 1.4.0    | TR-069 CWMP ACS Simulator
genieacs-sim              | TR-069 client…       | =zaidka         | 2017-02-05 | 0.9.0    | TR-069 CWMP ACS

Instale o genieacs

# npm install -g genieacs

added 129 packages in 8s

12 packages are looking for funding
  run `npm fund` for details

Crie um usuário do sistema para executar daemons GenieACS

# useradd --system --no-create-home --user-group genieacs

Crie um diretório para salvar extensões e arquivo de ambiente
Usaremos o diretório /opt/genieacs/ext/ para armazenar scripts de extensão (se houver).

# mkdir /opt/genieacs
# mkdir /opt/genieacs/ext

Crie o arquivo /opt/genieacs/genieacs.envpara que irá conter as opções de configuração, que passamos ao GenieACS como variáveis de ambiente.

# vim /opt/genieacs/genieacs.env

Adicione:

GENIEACS_CWMP_ACCESS_LOG_FILE=/var/log/genieacs/genieacs-cwmp-access.log
GENIEACS_NBI_ACCESS_LOG_FILE=/var/log/genieacs/genieacs-nbi-access.log
GENIEACS_FS_ACCESS_LOG_FILE=/var/log/genieacs/genieacs-fs-access.log
GENIEACS_UI_ACCESS_LOG_FILE=/var/log/genieacs/genieacs-ui-access.log
GENIEACS_DEBUG_FILE=/var/log/genieacs/genieacs-debug.yaml
NODE_OPTIONS=--enable-source-maps
GENIEACS_EXT_DIR=/opt/genieacs/ext
GENIEACS_UI_JWT_SECRET=secret

Defina a propriedade e as permissões do arquivo:

# chown genieacs. /opt/genieacs -R
# chmod 600 /opt/genieacs/genieacs.env

Criar diretório de logs

# mkdir /var/log/genieacs
# chown genieacs. /var/log/genieacs

Configure os serviços no systemd

# systemctl edit --force --full genieacs-cwmp

Adicione:

[Unit]
Description=GenieACS CWMP
After=network.target

[Service]
User=genieacs
EnvironmentFile=/opt/genieacs/genieacs.env
ExecStart=/usr/bin/genieacs-cwmp

[Install]
WantedBy=default.target

# systemctl edit --force --full genieacs-nbi

Adicione:

[Unit]
Description=GenieACS NBI
After=network.target

[Service]
User=genieacs
EnvironmentFile=/opt/genieacs/genieacs.env
ExecStart=/usr/bin/genieacs-nbi

[Install]
WantedBy=default.target

# systemctl edit --force --full genieacs-fs

Adicione:

[Unit]
Description=GenieACS FS
After=network.target

[Service]
User=genieacs
EnvironmentFile=/opt/genieacs/genieacs.env
ExecStart=/usr/bin/genieacs-fs

[Install]
WantedBy=default.target

# systemctl edit --force --full genieacs-ui

Adicione:

[Unit]
Description=GenieACS UI
After=network.target

[Service]
User=genieacs
EnvironmentFile=/opt/genieacs/genieacs.env
ExecStart=/usr/bin/genieacs-ui

[Install]
WantedBy=default.target

Configure o logrotate para rotação dos log gerados

# vim /etc/logrotate.d/genieacs

/var/log/genieacs/*.log /var/log/genieacs/*.yaml {
    daily
    rotate 30
    compress
    delaycompress
    dateext
}

Ative e inicie serviços, e revise a mensagem de status de cada um para verificar se os serviços estão sendo executados com êxito.

# systemctl enable genieacs-cwmp genieacs-nbi genieacs-fs genieacs-ui
# systemctl start genieacs-cwmp genieacs-nbi genieacs-fs genieacs-ui
# systemctl status genieacs-cwmp genieacs-nbi genieacs-fs genieacs-ui --no-pager

● genieacs-cwmp.service - GenieACS CWMP
     Loaded: loaded (/etc/systemd/system/genieacs-cwmp.service; enabled; vendor preset: enabled)
     Active: active (running) since Fri 2021-10-29 11:33:02 -03; 12s ago
   Main PID: 2487 (node)
      Tasks: 25 (limit: 2305)
     Memory: 155.5M
        CPU: 4.957s
     CGroup: /system.slice/genieacs-cwmp.service
             ├─2487 node /usr/bin/genieacs-cwmp
             ├─2494 /usr/bin/node /usr/bin/genieacs-cwmp
             └─2495 /usr/bin/node /usr/bin/genieacs-cwmp

● genieacs-nbi.service - GenieACS NBI
     Loaded: loaded (/etc/systemd/system/genieacs-nbi.service; enabled; vendor preset: enabled)
     Active: active (running) since Fri 2021-10-29 11:33:30 -03; 11ms ago
   Main PID: 2531 (node)
      Tasks: 6 (limit: 2305)
     Memory: 840.0K
        CPU: 3ms
     CGroup: /system.slice/genieacs-nbi.service
             └─2531 node /usr/bin/genieacs-nbi

● genieacs-fs.service - GenieACS FS
     Loaded: loaded (/etc/systemd/system/genieacs-fs.service; enabled; vendor preset: enabled)
     Active: active (running) since Fri 2021-10-29 11:33:41 -03; 12ms ago
   Main PID: 2596 (node)
      Tasks: 6 (limit: 2305)
     Memory: 840.0K
        CPU: 3ms
     CGroup: /system.slice/genieacs-fs.service
             └─2596 node /usr/bin/genieacs-fs

● genieacs-ui.service - GenieACS UI
     Loaded: loaded (/etc/systemd/system/genieacs-ui.service; enabled; vendor preset: enabled)
     Active: active (running) since Fri 2021-10-29 11:33:51 -03; 28ms ago
   Main PID: 2639 (node)
      Tasks: 7 (limit: 2305)
     Memory: 7.7M
        CPU: 20ms
     CGroup: /system.slice/genieacs-ui.service
             └─2639 node /usr/bin/genieacs-ui

Acesse em seu navegador: http://IP:3000

Clique em: ABRACADABRA!

Clique em: Open Sesame!

Entre com: admin/admin

Grupo do telegram: ACS/CWMP – TR069 – Brasil (PT-Br)

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 TR-069 – Instalação do GenieACS no Debian 11 Bullseye apareceu primeiro em Remontti.

Neste tutorial vamos aprender a configurar nossas interfaces de rede no Debian e estar pensando um pouco mais para fazer uma boa escolha na hora de realizar suas configurações.

Antes de mais nada você precisa saber o que você quer!? Qual será o cenário!? Vejo muitas pessoas cometerem um desastre nos dias hoje quando se trata em colocar um simples IP público em um servidor. E por isso escrevo este “artigo” meio que tutorial.

No Debian você pode configurar os endereços IPs bem como algumas regras no arquivo /etc/network/interfaces, irei levar como base uma instalação recém-feita:

– Instalação do Debian 13 Trixie
– Instalação do Debian 12 Bookworm
– Instalação do Debian 11 Bullseye
– Instalação do Debian 10 Buster

Irei usar o editor nano que é o que já vem instalado, mas você pode usar o editor de sua escolha.

# nano /etc/network/interfaces

Se em sua instalação você informou o endereço IPv4 seu arquivo será algo como este, ressaltando que ens18 é o nome da interface, e ela pode ser outra.

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
allow-hotplug ens18
iface ens18 inet static
        address 192.168.87.3/24
        gateway 192.168.87.1
        # dns-* options are implemented by the resolvconf package, if installed
        dns-nameservers 1.1.1.1 8.8.8.8

Alterar DNS

Por mais que vimos dns-nameserver nesta parte da configuração de rede, o servidor não irá usa-los, o arquivo qual será levado em conta é o /etc/resolv.conf

# nano /etc/resolv.conf

nameserver 1.1.1.1
nameserver 1.0.0.1
nameserver 2606:4700:4700::1111
nameserver 2606:4700:4700::1001

Se sua instalação foi feita com DHCP ativo, sua configuração será:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
allow-hotplug ens18
iface ens18 inet dhcp

E ai, o que queremos ?

Planejar, é claro! Se você esta montando seu data center onde terá vários servidores, o que será melhor adorar? Quebrar um prefixo /30 para cada servidor que eu for implementar? NÃO!. Quer me ver com os olhos sangrando é ver alguém que tem vários servidores e para cada servidor o mesmo quebrou um /30 público. Pense comigo você tem 2 servidores você precisa 2 IPs, se você quebrou 2 /30 você terá sim seus 2 IPs públicos mas você acabou de jogar no LIXO outros 6 endereços IPs, e nos dias de hoje 1 único IP publico é quase como o ditado: Em terra de cego, quem tem um olho é rei?

Então o que fazer, o mais sensato é você pensar e quebrar um prefixo maior para que você não precise estar quebrando prefixos a cada servidor. Antes de mais nada imagine onde você quer chegar! Quantos servidores irá montar, quantos IPs publicos e privados irá precisar… Sempre que dou uma consultoria essa é a primeira coisa faço, “sento” com o cliente e estudo. E com base neste estudo reservamos já um/dois prefixo /29, /28 ou 27 até mesmo um /24 público/privado, vai depender muito de cada cenário, se meu cliente tem milhares de hospedagem com certeza o número de servidores em seu data center é enorme.

Outro grande erro em servidores é o NAT mal aplicado! Muitas pessoas principalmente pessoal de provedor ainda tem costume de colocar em seu Mikrotik de borda um belo NAT para fornecer internet a um servidor, ou apenas para fazer um redirecionamento de portas. Quando aplicamos regras de NAT em um roteadores causamos muitos malefícios para o bichinho! Então vamos para de fazer isso? Vou lhe ajudar!

É claro que isso é muito relativo de cada empresa, já fiz NAT com borda? Já! Depende do tamanho da empresa e organização de cada um. Então não leve ao pé da letra! Estou tentando lhe dizer o que é o melhor a ser feito!

Já fui criticado por pedir para cliente comprar uma roteador para ser apenas o gateway dos servidores. “Rudimar é louco”. E eu digo: Mais louco é quem faz NAT em roteador de borda! . Em alguns casos eu recomendo um router para ligar os servidores, pois você pode ter diversos recursos na manga, e basta você fechar um iBGP/OSPF entre seu roteador de borda com seu roteador “data”.

Exemplos

Receber IP via DHCP

O mais simples a ser feito quando seu servidor ira receber IP automaticamente.

allow-hotplug ens18
iface ens18 inet dhcp

Fixando IPv4 e IPv6

Basicamente o que iremos usar em 95% das vezes

allow-hotplug ens18
iface ens18 inet static
        address 200.200.200.2/28
        gateway 200.200.200.1

iface ens18 inet6 static
        pre-up modprobe ipv6
        address 2804:bebe:cafe::2/64
        gateway 2804:bebe:cafe::1

Adicionando Multiplos IPs

Quando quiser mais de um IP no mesmo servidor, caso for outras interfaces basta ajustar para o nome da interface

allow-hotplug ens18
iface ens18 inet static
        address 200.200.200.2/28
        gateway 200.200.200.1

iface ens18 inet static
        address 200.200.200.3/28

iface ens18 inet static
        address 200.200.201.1/32

iface ens18 inet6 static
        pre-up modprobe ipv6
        address 2804:bebe:cafe::2/64
        gateway 2804:bebe:cafe::1

iface ens18 inet6 static
        pre-up modprobe ipv6
        address 2804:bebe:cafe::3/64

iface ens18 inet6 static
        pre-up modprobe ipv6
        address 2804:bebe:ffff:ffff::ffff
        netmask 128

IP na Loopback

Você pode usar quando estiver roteando um IP (OSFP/iBGP), exemplo com FRR, porém neste caso estaria fazendo a adição dos IPs pelo próprio FRR.
Mas se você fará algum tipo de rota estática com intuito exemplo de fazer ECMP (Equal Cost Multi-Path), é importante que os IPs de anycast estejam na interface de loopback para que não tenha conflito.

auto lo 
iface lo inet loopback

iface lo inet static
        address 200.200.200.200/32

Ponto a ponto – Pointopoint

Aqui muitos ficam bugado, no meu cenário perceba que temos um servidor conectado ao roteador de borda, agora imagine, que neste roteador de borda não tem nenhum IP público por politicas de segurança, mas ai vem o estagiário e e te diz: Vamos quebrar um /30 pub! Então saiba que você não precisa fazer isso, você pode adicionar um IP ponto a ponto, onde temos IP diferente dos dois lados, então como no exemplo a baixo podemos add no nosso roteador de borda 10.50.50.1 e no nosso servidor 200.200.200.0.

allow-hotplug ens18
iface ens18 inet static
        address 200.200.200.0
        pointopoint 10.50.50.1
        netmask 255.255.255.255
        gateway 10.50.50.1

Isso funciona? É claro! E você não irá precisar deixar seu roteador de borda com IP público acessível pelo mundo, e muito menos fazer um NAT! Como sou bonzinho vou deixar aqui como você configuraria isso no seu Mikrotikão! Ficaria assim:

RouterOS# /ip address
RouterOS# add address=10.50.50.1 comment=Pointopoint interface=ether1 network=200.200.200.0

Simples não?! Testa ai! Depois me conta!

Privado com saída em origem Público

Quase que como o exemplo do pointopoint, porem em alguns roteadores não temos o suporte para fazer pointopoint, uma saída é você quebrar um prefixo privado (estou usando /30, mas se tivesses vários servidores junto faria já um prefixo maior). No exemplo então meu IP público é o 200.200.200.200/32 qual irei colocar na mesma interface da WAN que tenho o 10.33.33.2/30, logo o roteador é o 10.33.33.1. Desta forma você tem uma conversa entre as interfaces por IP privado, porem os pacotes são originados com o endereço de IP público.

allow-hotplug ens18
iface ens18 inet static
    address 200.200.200.200/32
iface ens18 inet static
    address 10.33.33.2/30
    post-up ip route add default via 10.33.33.1 src 200.200.200.200

Mas ai temos um problema, seu servidor irá gerar os pacotes de origem publico, e irá enviar para internet, mas quando o pacote estiver voltando ao chegar em seu roteador de borda é necessário que você tenha uma rotá para o mesmo. Então crie um rota estática dizendo que Destino 200.200.200.200 o gateway é 10.33.33.2 IP este do seu servidor. Ex.:

Exemplo RouterOS:

RouterOS# /ip address add address=10.33.33.1/30 interface=ether2
RouterOS# /ip route add dst-address=200.200.200.200/32 gateway=10.33.33.2

Exemplo Huawei:

ip route-static 200.200.200.200 32 10.33.33.2 preference 1 description SERVIDOR

É possível fazer isso para IPv6 também? É claro!

allow-hotplug ens18

#IPv6 Público
iface ens18 inet6 static
        pre-up modprobe ipv6
        address 2804:bebe:cafe::cafe
        netmask 128

# IPv6 Privado
iface ens18 inet6 static
        pre-up modprobe ipv6
        address fd00:a::2/64
        post-up ip -6 route add default via fd00:a::1 src 2804:bebe:cafe::cafe

Exemplo RouterOS:

RouterOS# /ipv6 address add address=fd00:a::1/64 advertise=no interface=ether2
RouterOS# /ipv6 route add dst-address=2804:bebe:cafe::cafe/128 gateway=fd00:a::2

Exemplo Huawei:

ipv6 route-static 2804:bebe:cafe::cafe 128 fd00:a::2 preference 1 description SERVIDOR

Possível problema: Resolução ARP/ND na Inicialização

Em alguns casos, pode acontecer do IP /32 (no IPv4) ou /128 (no IPv6) só começar a funcionar após um primeiro ping interno. Isso não significa que a configuração da rede esteja errada, mas sim que o kernel e o roteador precisam “descobrir” via ARP/ND como chegar a esse endereço adicional.

Esse comportamento ocorre porque, ao usar um endereço /32 (IPv4) ou /128 (IPv6), o roteador e o kernel do Linux não enviam nem respondem a requisições ARP/ND de forma “espontânea” para esse IP adicional. Somente quando há tráfego partindo do servidor (por exemplo, um ping), a troca de ARP/ND é feita e o roteador “aprende” para onde enviar os pacotes que chegam nesse IP público. Sem essa “ativação” inicial, o roteador não tem como saber que aquele IP /32 ou /128 está associado à interface do servidor.

No Debian 13 eu contornei desta forma:

allow-hotplug ens18
iface ens18 inet static
    address 200.200.200.200/32
    up ip addr add 10.33.33.200/24 dev $IFACE
    up ip route replace default via 10.33.33.1 dev $IFACE  src 200.200.200.200
    down ip route del default via 10.33.33.1 dev $IFACE || true
    down ip addr del 10.33.33.2/24 dev $IFACE || true

iface ens18 inet6 static
    address 2804:bebe:cafe::cafe/128
    up ip -6 addr add fd00:a::2/64 dev $IFACE
    up ip -6 route replace default via fd00:a::1 dev $IFACE
    down ip -6 route del default via fd00:a::1 dev $IFACE || true
    down ip -6 addr del fd00:a::1/64 dev $IFACE || true

Se ainda não resolver tente com o script:

Crie o serviço systemd

# vim /etc/systemd/system/meu_script_rede.service

Adicione:

[Unit]
Description=Rodar script após inicialização da rede
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/meu_script.sh
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target

Crie o script, nele vamos incluir um ping

# vim /usr/local/bin/meu_script.sh

Ajuste IPV4_GATEWAY e IPV6_GATEWAY para seus gateway.

#!/bin/bash

# IPs
IPV4_GATEWAY="10.33.33.1"
IPV6_GATEWAY="fd00:cafe::1"

# Nº de pings
NPING=5

# Registro no log
date > /var/log/rede_inicializada.log
echo "A placa de rede foi inicializada" >> /var/log/rede_inicializada.log

# Enviar pings para forçar ARP/ND
ping -O -4 -c $NPING $IPV4_GATEWAY >> /var/log/rede_inicializada.log
ping -O -6 -c $NPING $IPV6_GATEWAY >> /var/log/rede_inicializada.log

# Espera 1 segundo
sleep 1

Dê permissão de execução:

# chmod +x /usr/local/bin/meu_script.sh

Ative o serviço no systemd e reinicie

# systemctl daemon-reload
# systemctl enable meu_script_rede
# systemctl start meu_script_rede
# systemctl status meu_script_rede

Agora, toda vez que o servidor inicializar, este script rodará e enviará alguns pings para “ativar” as tabelas ARP e ND. Você poderá verificar o arquivo /var/log/rede_inicializada.log para ver a saída dos pings. `cat /var/log/rede_inicializada.log`

Criando VLAN e adicionado IP nela

Para adicionar um IP a uma VLAN precisamos carregar o módulo 8021q, e coloca-lo para iniciar com sistema.

# modprobe 8021q
# echo "8021q" >> /etc/modules

Agora basta editar sua interface e incluir um ponto e o numero da VLAN. No exemplo VLAN 171

allow-hotplug ens18.171
iface ens18.171 inet static
       address 10.88.88.2/24

PBR – Roteamento baseado em políticas

Eu particularmente uso em Accel-ppp para separar o trafego de IPs publicos de Privados, direcionando apenas os IPs de NAT para a caixa do CGNAT. É necessário criar uma nova tabela de rotas, irei chamar de cgnat no exemplo.

# echo "100 cgnat" >> /etc/iproute2/rt_tables
# cat /etc/iproute2/rt_tables
# ip route list table main

Fecho um /30 entre router e servidor e digo que todos os IPs que 100.64.0.0./10 deve sair pela tabela de rotas com o CGNAT.

allow-hotplug ens18
iface ens18 inet static
    address 10.200.200.2/30
    post-up ip route add default via 10.200.200.1 dev ens18 table cgnat
    post-up ip rule add from 100.64.0.0/10 lookup cgnat

Blackhole

Normalmente útil em casos que você usa seu servidor como roteador. Você irá colocar após as configurações da interface o post-up passando o prefixo ou ip qual irá subir em blackhole

allow-hotplug ens18
iface ens18 inet static
    address 10.33.33.2/30
    post-up ip route add blackhole 200.200.200.128/26 metric 250 || true

Agregação

Instalar o ifenslave: Este pacote permite configurar a agregação de portas no Linux.

# apt install ifenslave

Carregar o Módulo de Bonding

# echo "bonding" | tee -a /etc/modules
# modprobe bonding

Verificar se o módulo foi carregado corretamente:

# lsmod | grep bonding

802.3ad (LACP): Ideal para aumentar a largura de banda e fornecer redundância quando conectado a um switch que suporta LACP.
balance-xor: Útil para balanceamento de carga baseado em XOR, adequado para ambientes que não suportam LACP.
balance-rr (Round Robin): Simples e eficaz para cargas de trabalho que exigem balanceamento de carga sem configuração específica do switch.
active-backup: Fornece redundância sem aumento de largura de banda, útil quando a continuidade do serviço é mais crítica do que a capacidade.
balance-tlb (Transmit Load Balancing) e balance-alb (Adaptive Load Balancing): Ambos são bons para ambientes onde a configuração do switch não pode ser alterada ou não suporta LACP. O ALB também tenta balancear o tráfego de entrada.

Aqui estão exemplos para vários modos de bonding

# vim /etc/network/interfaces

802.3ad (LACP)

Aplicação: Ideal para ambientes de alta disponibilidade e alta largura de banda, como data centers ou servidores que precisam de conexões robustas e de alta capacidade. É necessário que ambos os lados (o Debian e o switch/router) suportem LACP.

auto bond0
iface bond0 inet static
    address 192.168.0.2/24
    bond-slaves enp4s0f0 enp4s0f1
    bond-miimon 100
    bond-mode 802.3ad
    bond-xmit-hash-policy layer2+3

Balance-xor

Aplicação: Bom para ambientes onde o tráfego de rede tem padrões conhecidos que podem ser distribuídos de forma eficaz usando XOR. Pode ser usado para melhorar o desempenho quando LACP não é suportado.

auto bond0
iface bond0 inet static
    address 192.168.0.2/24
    bond-slaves enp4s0f0 enp4s0f1
    bond-miimon 100
    bond-mode balance-xor
    bond-xmit-hash-policy layer2+3

Balance-rr (Round Robin)

Aplicação: Simples e eficaz para distribuir cargas de forma equitativa sobre as interfaces físicas. Útil em ambientes onde a ordem de chegada dos pacotes não é crítica.

auto bond0
iface bond0 inet static
    address 192.168.0.2/24
    bond-slaves enp4s0f0 enp4s0f1
    bond-miimon 100
    bond-mode balance-rr

Active-backup

Aplicação: Ideal para redundância sem aumentar a largura de banda. Se a interface primária falhar, outra assumirá. Recomendado para serviços críticos que precisam de alta disponibilidade mais do que de alta capacidade.

auto bond0
iface bond0 inet static
    address 192.168.0.2/24
    bond-slaves enp4s0f0 enp4s0f1
    bond-miimon 100
    bond-mode active-backup
    bond-primary enp4s0f0

Balance-tlb (Transmit Load Balancing)

Aplicação: Útil quando a modificação de configuração do switch não é possível. Realiza o balanceamento de carga de saída de acordo com a carga atual de cada interface. Não requer suporte específico do switch.

auto bond0
iface bond0 inet static
    address 192.168.0.2/24
    bond-slaves enp4s0f0 enp4s0f1
    bond-miimon 100
    bond-mode balance-tlb

Balance-alb (Adaptive Load Balancing)

Aplicação: Similar ao balance-tlb, mas também tenta balancear o tráfego de entrada, o que pode ser útil em servidores web ou de aplicativos. Essa modalidade não requer configuração especial do switch.

auto bond0
iface bond0 inet static
    address 192.168.0.2/24
    bond-slaves enp4s0f0 enp4s0f1
    bond-miimon 100
    bond-mode balance-alb

Reiniciar o sistema para aplicar as alterações:

# reboot

Verificar o status do serviço de rede para garantir que não houve erros, e a configuração de bonding.

# systemctl status networking
# journalctl -u networking.service
# cat /proc/net/bonding/bond0

Considerações finais

Sempre que editar o arquivo /etc/network/interfaces para que as configurações sejam carregadas será necessário reiniciar seu servidor, você até pode subir a interface com auto ao invés de allow-hotplug, mas não irei abordar aqui.

Caso você queira adicionar/remover IPs manualmente (em memória/perde ao reiniciar) você pode usar o comando ip, segue exemplo, onde ens18 é o nome da interface.
Adicionar:

# ip addr add 192.168.7.7/32 dev ens18
# ip -6 addr add 2001:db8:1::1/128 dev ens18

Visualizar:

# ip address

Remover:

# ip addr del 192.168.7.7/32 dev ens18
# ip -6 addr del 2001:db8:1::1/128 dev ens18

Exibe interfaces / Endereços IPs

# ip -br a
# ip -br addr show
# ip -br link
# ip -br link show

Exibir informações sobre todas as interfaces de rede:

# ip a
# ip addr
# ip addr show

Exibir informações sobre todas as interfaces de rede IPv4:

# ip -4 a

Exibir informações sobre todas as interfaces de rede IPv6:

# ip -6 a

Exibir informações sobre uma interface de rede específica:

# ip a show eth0
# ip a list eth0
# ip a show dev eth0

Mostrar apenas interfaces em execução

# ip link ls up

Adicionar um endereço IPv4/IPv6:

# ip a add {ip_addr/mask} dev {interface}
# ip a add 10.0.1.200/255.255.255.0 dev eth0
# ip a add 10.0.1.200/24 dev eth0

Remover endereço IP

# ip a del {ipv6_addr_OR_ipv4_addr} dev {interface}
# ip a del 10.0.1.200/24 dev eth0

Desligando a interface

# ip link set dev eth1 down

Ligando a interface

# ip link set dev eth1 up

Ajusda

# man ip
# ip --help

Comandos antigos X Novo comando

Velho # ifconfig -a
 Novo # ip a

Velho # ifconfig eth0 down
 Novo # ip link set eth0 down

Velho # ifconfig eth0 up
 Novo # ip link set eth0 up

Velho # ifconfig eth0 10.0.2.24
 Novo # ip addr add 10.0.2.24/24 dev eth0

Velho # ifconfig eth0 netmask 255.255.255.0
 Novo # ip addr add 10.0.1.1/24 dev eth0

Velho # ifconfig eth0 mtu 9000
 Novo # ip link set eth0 mtu 9000

Velho # ifconfig eth0:0 10.0.2.25
 Novo # ip addr add 10.0.2.25/24 dev eth0

Velho # netstat -g
 Novo # ip maddr

Velho # route
 Novo # ip r

Velho # route add -net 10.0.2.0 netmask 255.255.255.0 dev eth0
 Novo # ip route add 10.0.2.0/24 dev eth0

Velho # route add default gw 10.0.2.254
 Novo # ip route add default via 10.0.2.254

Velho # arp -a
 Novo # ip neigh

Velho # arp -v
 Novo # ip -s neigh

Velho # arp -s 10.0.2.33 01:02:03:04:05:06
 Novo # ip neigh add 10.0.3.33 lladdr 01:02:03:04:05:06 dev eth0

Velho # arp -i eth0 -d 10.0.2.254
 Novo # ip neigh del 10.0.2.254 dev eth0

Velho # netstat
 Novo # ss

Velho # netstat -tulpn
 Novo # ss -tulpn

Velho # netstat -neopa
 Novo # ss -neopa

Espero ter colaborado com uma pequena parcela em seu conhecimento! Desculpa o português e as palavras faltando letras, é difícil conseguir tempo para vir aqui escrever e revisar, então abro meu “bloco de notas” e vou escrevendo…

Curtiu o conteúdo? Quer me ajudar manter o blog?

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.

Abraço!

O post Configurando interface de rede no Debian 10/11/12/13 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.

Para montar o servidor vamos usar um projeto muito simples que basicamente tem 2 arquivos, o PHP Looking Glass qual é um fork do projeto russo hsdn.

Você encontra outros projetos legais também como o da respawner qual o pessoal da BPF já fez tutorial sobre o mesmo.

Características do PHP Looking Glass

Suporte a Telnet e SSH (plink ou sshpass).
Suporte aos roteadores Cisco, MikroTik (RouterOS), Juniper, Huawei (Comware), Quagga (Zebra) e OpenBGPD.
Suppores aos protocolos IPv4 e IPv6.
Conversão automática de IPs em sub-redes usando Merit RADb para MikroTik (http://www.ra.net/).
Desenho do gráfico BGP AS usando o kit de ferramentas GraphViz.
Funciona no php 5.2.0 e superiores.

Para subir o projeto em seu servidor você precisa ter um serviço web como apache por exemplo e PHP basicamente. Você pode subir ele em um servido já em produção, não é necessário criar um servidor apenas para essa finalidade. (Porém fica a seu critério)

Vou trazer uma instalação limpa com base na instalação zerada do Debian 10.

Com Debian instalado vamos instalar os pacotes necessários:

# apt install apache2 apache2-utils sshpass graphviz
# apt install libapache2-mod-php php php-cli php-pear php-gmp php-gd php-bcmath php-mbstring php-curl php-xml php-zip
# pear install Image_GraphViz-1.3.0

Vou colocar o projeto no diretório padrão do apache /var/www/html/, mas você pode criar um domínio virtual para isso ficar muito mais legal e ainda criar um certificado gratuitamente com o Let’s Encrypt

# mkdir /var/www/html/lg
# cd /var/www/html/lg
# apt install wget
# wget https://github.com/remontti/lg/raw/master/htdocs/favicon.ico
# wget https://github.com/remontti/lg/raw/master/htdocs/lg_logo.gif
# wget https://raw.githubusercontent.com/remontti/lg/master/htdocs/index.php
# wget https://raw.githubusercontent.com/remontti/lg/master/htdocs/lg_config.php

Agora basta vocÊ editar o arquivo lg_config.php e alterar os valores das variáveis:

$_CONFIG[‘asn’] – Seu AS para exibição na página LG.
$_CONFIG[‘company’] – Nome da empresa para exibição na página LG.
$_CONFIG[‘logo’] – O logotipo da sua empresa para exibição na página LG.
$_CONFIG[‘color’] – Cor principal dos elementos de design na página LG.

A configuração dos roteadores é especificada em $_CONFIG[‘routers’], no seguinte formato:

$_CONFIG['routers'] = array
(
    'router1' = array
    (
        // Router valores
    ),
    'router2' = array
    (
        // Router valores
    ),
    // etc.
);

No nosso arquivo atual já consta com 3 exemplos sendo um o do IX.BR (SP). Basta você configurar seu roteado seguindo os padrões:

url – Endereço no formato: [ssh|telnet]://[login]:[password]@[host]:[port].
pingtraceurl – Endereço URL para ferramentas de ping e traceroute para roteadores Quagga (ou * FALSE *).
description – Descrição do roteador.
group – Nome do grupo de roteadores (AS) (ou FALSE).
ipv6 – Suporte IPv6? (TRUE ou FALSE).
os – Tipo do Router (ios, mikrotik, quagga, junos, openbgpd, huawei).

Configurações ajustada basta acessar o endereço http://ip-servidor/lg ou se você fez bonitinho via domínio

Curtiu o conteúdo? Quer me ajudar?

Se quiser fazer uma doação para o café ficarei muito feliz pelo seu reconhecimento! (Esse deu trabalho!)

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.

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

Abraço!

Demos
http://dev.hsdn.org/lg/
http://lg.campus-rv.net/
http://lg.lankabell.com/

Gráfico da demonstração (BGP AS)
http://dev.hsdn.org/lg/?command=graph&protocol=ipv4&query=8.8.8.8&router=example1

O post Servidor Looking Glass simples e rápido! apareceu primeiro em Remontti.

Fortalecendo a Resiliência da Rede: Detecção de Ataques DDoS com FastNetMon, FRRouting, Grafana e Implementação em Debian 12 com Huawei & RouterOS

#
#
#
#
#
#
#
#

Neste tutorial vamos aprender como identificar os ataques Dos/DDoS e anunciar os prefixo atacados (ou atacantes) de seu AS em envia-los para uma blackhole, e repassar os mesmo para sua operadora. (Acordo)

Vamos utilizar o FastNetMon que é um analisador de carga DoS/DDoS de alto desempenho, construído sobre vários mecanismos de captura de pacotes (NetFlow, IPFIX, sFlow, AF_PACKET, SnabbSwitch, netmap, PF_RING, PCAP).

Farei a instalação do FastNetMon no Debian 10 (Instalação Limpa)

Você irá precisar configurar o envido dos Flows em seu roteador de bora. Vou deixar aqui um exemplo de como configurar com o routerOS/Mikrotik.

Cenário Ex.:
AS – 15169
172.31.31.1/30 – RouterOS/Mikrotik
172.31.31.2/30 – Servidor FastNetMon

Ative o envido dos flows em seu routerOS/Mikrotik, selecionando as interfaces de entrada (WAN) ex suas operadoras, PTTs (No exemplo sfp1,VLAN.1234-PTT) observe que não irei usar a porta padrão 2055 e sim 62055.

/ip traffic-flow set active-flow-timeout=1m cache-entries=4k enabled=yes interfaces="sfp1,VLAN.1234-PTT"
/ip traffic-flow target add dst-address=172.31.31.2 port=62055

Instalação FastNetMon

Antes de iniciar a instalação do seu do seu servidor em nosso exemplo estou usando o IP 172.31.31.2/30, porém eu NUCA recomendaria você fazer NAT em seu roteador de borda ainda mais ele sendo um Mikrotik, a performasse estaria comprometida, quem tem NAT estude de uma pesquisada sobrem IPv4 Fast Path, IPv4 Fasttrack, Connection Tracking. Quando você compreender esses “caras” e aplicar dentro de sua rede, vai descobrir que o mikrotik não é tão ruim quanto falam por ai kkkkk. (Quem sabe um dia escrevo algo sobre), mas voltando… Porque utilizar o IP 172.31.31.2 então? Primeiramente por que ele não é acessível pelo mundo, logo não pode ser atacado, mas por outro lado se ele não tiver internet você não poderá por exemplo configurar para receber uma notificação (que neste tutorial vou explicar como fazer para enviar alertas no telegram) então como proceder, se você manja já deve ter pensado em uma solução. No meu caso eu sempre divido a a rede, o que é borda é borda, nunca ligo um servidor nela! O ideal é termos um router apenas para os servidores, ou então ligado quem sabe no concentrador de NAT, então nesse caso você pode fazer uma NAT para seu servidor, na pior das hipóteses use um ip válido. Você pode também fechar uma sessão multihop. Bom de seus pulos, ai já é engenharia de redes!

O pacote do fastnetmon já se encontra no repositório do debian, juntamente algumas pacotes extras que vamos utilizar em seguida.

# apt install fastnetmon zip curl wget python-pip socat -y

Adicione todos os prefixos de se AS, são esses os IPs que ele fará analise.

# vim /etc/networks_list

Exemplo

216.58.192.0/22
2800:3f0::/32

Ajustes as configurações

# vim /etc/fastnetmon.conf

Exlplicarei nos comentários

# Quantos pacotes serão coletados do tráfego de ataque
# Aumentamos para ter um log com mais informações
ban_details_records_count = 1000

# Defina por quanto tempo você irá ficar anunciando seu IP atacado a blackhole 
ban_time = 600

# Ative o rastreamento de conexão
enable_connection_tracking = on

# Ativaremos a detecção de ataques, por pacotes por/s, por limite de banda e pro flows.
ban_for_pps = on
ban_for_bandwidth = on
ban_for_flows = on

# Limites de pacotes
threshold_pps = 20000
# Limite de banda (Pode pegar como base o cliente/ plano com mair trafego 
# cuidado com ips de cgnat, eles terão bem mais consumo. 
threshold_mbps = 1000
# Limite por flows
threshold_flows = 3500

# Você pode desativar o sflow (Já que com RouterOS não vamos utiliza-lo)
sflow = off

# Ative o netflow
netflow = on

# Ative o exabgp (É com ele que vamos fechamos nosso per com a borda)
exabgp = on
# Defina para 60 o mesmo tempo setado la no Router (active-flow-timeout=1m)
average_calculation_time = 60

# Altere a porta para mesma que configuramos no Router
netflow_port = 62055

# Informe o IP da sua interface do servidor
exabgp_next_hop = 172.31.31.2

# Script que será executado sempre quer um banir/desbanir
notify_script_path = /usr/local/bin/notify_about_attack.sh

O fastnetmon sempre que identificar um ataque irá executar notify_script_path, identificando o IP da sua rede que está sofrendo (incoming) o ataque ou que está cometendo (outgoing) o ataque. Ele NÃO irá identificar os IPs de origem. Em um futuro quando tivermos mais testes elaborados eu juntamente com o Gabriel Vargas Padilha estamos estudando os logs e através desses com um script (python) analisarmos a fundo vamos armazena-los em uma base de dados bem como identificar (porem no momento ainda tem falsos positivos), mas a ideia e saber a origem e através de um outro script notificar os IPs de origens enviando os logs para o dono do IP para que ele tome suas providencias, e por que não anunciar também nas blackholes.

Criaremos então nosso arquivo chamado pelo opção “notify_script_path”, mas antes vamos criar um script para enviar notificações (mensagens) e arquivos pelo Telegram. Vai ser necessário criar um bot do telegram para o uso do mesmo. Se você não sabe como criar um Bot para telegram veja como fazer o mesmo no início do tutorial que já postei de como enviar alertas pelo zabbix, Zabbix 4.2 enviando alertas no Telegram via Bot (Debian 10), lá no ínico do tutorial explica como criar o bot, pegar o token e como descobrir o ID de um usuário ou grupo.

# cd /tmp/
# wget https://github.com/remontti/TelegramCMD/archive/master.zip
# unzip /tmp/master.zip
# chmod a+x /tmp/TelegramCMD-master/telegram
# mv /tmp/TelegramCMD-master/telegram* /usr/local/bin/

Não esqueça de alterar o TOKEN para o do seu bot.

# vim /usr/local/bin/telegram.conf/token.conf

######################################
# Telegram bot                       #
# Create a new bot with @BotFather   #
# get TOKEN                          #
######################################

TOKEN="000000000:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

Como usar? É importante você saber que o IDs de grupos tem um “-” no inicio do ID, já usuários direto não.

Uso: telegram [Opções]
  -m: Para enviar uma mensagem
     ex: telegram -m "ID Chat" "Meu assunto" "Minha mensagem..."
     ex: telegram -m "-123456789" "Notificação" "Mensagem para um grupo ID"
     ex: telegram -m "123456789" "Notificação" "Mensagem para direta/privado"

  -f: Para enviar um arquivo
     ex: telegram -f "ID Chat" "/diretorio/arquivo" "nome do arquivo zip" "Comentário"
     ex: telegram -f "12345689" /var/log/syslog syslog "Logs do sistema para user privado"

ex: telegram -f “-12345689” /var/log/syslog syslog “Logs do sistema para um grupo”

Bot funcionando, criamos então uma pasta onde os logs de ataques que terminaram vão ser movidos, e o script que será executado sempre que um ataque for identificado (BAN/UNBAN).

# mkdir /var/log/fastnetmon_attacks/ataques
# vim /usr/local/bin/notify_about_attack.sh

#!/usr/bin/env bash

# This script will get following params:
#  $1 client_ip_as_string
#  $2 data_direction
#  $3 pps_as_string
#  $4 action (ban or unban)

# Desbanindo um IP
if [ "$4" = "unban" ]; then
    /usr/local/bin/telegram -m "-12345678" "UNBAN: $2 Ataque" "<code>IP $1</code> removido da blackhole"
    # Movemos os logs para pasta ataques pois não queremos mais receber elas.
    mv /var/log/fastnetmon_attacks/$1* /var/log/fastnetmon_attacks/ataques
    # Unban actions if used
    exit 0
fi

# Banindo
if [ "$4" = "ban" ]; then
    /usr/local/bin/telegram -m "-12345678" "BAN: $2 ataque" "<code>IP $1</code> prefixo anunciado a blackhole"
    /usr/local/bin/telegram -f "-12345678" /var/log/fastnetmon_attacks/$1* $1 "Logs do ataque ao IP $1"
    exit 0
fi

if [ "$4" == "attack_details" ]; then    
    #/usr/local/bin/telegram -m "-12345678" "BAN" "<code>FastNetMon: IP $1 blocked because $2 attack with power $3 pps</code>"
    exit 0
fi

# chmod a+x /usr/local/bin/notify_about_attack.sh

Restarte o fastnetmon

# systemctl restart fastnetmon

Instalação do exaBGP

Iremos utilizar o exaBGP fechar nossa conexão BGP para realizar os anúncios dos prefixos atacados.

# pip install exabgp==3.4.20

Configure o arquivo para fechar o peer.

# vim /etc/exabgp.conf

group RouterBorda {
    hold-time 180;
    # AS do nosso ExaBGP (Pode deixar 65001)
    local-as 65001;
    # AS Remoto (Seu AS pois você vai estar fechando com seu roteador de borda)
    peer-as 15169;
    # ID do ExaBGP router (use o mesmo IP da sua placa de rede)
    router-id 172.31.31.2;
    graceful-restart 1200;
    # Remote peer
    neighbor 172.31.31.1 {
        # Endereço IP da interface desse servidor
        local-address 172.31.31.2;
        description "ExaBGP";
        family {
            ipv4 unicast;
            ipv6 unicast;
        }
    }
    # Processo que vai receber as linhas de comandos para adicionar ou excluir uma prefixo
    process service-dynamic {
        run /usr/bin/socat stdout pipe:/var/run/exabgp.cmd;
    }
}

Antes de iniciar o exaBGP você precisa criar um peer e alguns filtros em seu roteador de borda, no nosso exemplo routerOS/Mikrotik.

Filtros:
Crie um filtro de entrada que todas as rotas aprendida do fastnetmon seja setadas como blackhole, e não ensine nada para ele.

/routing filter
add action=accept chain=FastNetMon-IN set-type=blackhole
add action=discard chain=FastNetMon-OUT

Peer:
Atenção para a instance que deve estar selecionada corretamente (use a mesma que você usa com sua operadora). Caso seu servidor não esteja com um conexão direta a borda poe usar multihop=yes, como comentado anteriormente.

/routing bgp peer
add name=FastNetMon instance=default remote-as=65001 multihop=no  \
 in-filter=FastNetMon-IN out-filter=FastNetMon-OUT \
 remote-address=172.31.31.2 update-source=172.31.31.1

Para não ter que carregar na mão o exabgp, criaremos um script para inicialização do exaBGP automaticamente.

# vim /etc/init.d/exabgp 

#!/bin/bash
### BEGIN INIT INFO
# Provides:          exabgp
# Required-Start:    $all
# Required-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:
### END INIT INFO

VERMELHO='\033[1;31m'
VERDE='\033[1;32m'
NC='\033[0m'

PROCESSO=$(ps -x |grep -v "grep" |grep -v "/bin/bash" |grep exabgp |wc -l); 

function startExaBGP(){
    if [  $PROCESSO -eq 0 ]
    then
        echo "Iniciandos...";
        env exabgp.daemon.user=root \
          exabgp.daemon.daemonize=true \
          exabgp.daemon.pid=/var/run/exabgp.pid \
          exabgp.log.destination=/var/log/exabgp.log \
          exabgp /etc/exabgp.conf
        sleep 0.3
        echo -e "ExaBGP [${VERDE} Iniciado ${NC}] ";
    else
        echo -e "ExaBGP já exstá em execuxão. [${VERDE} Ativo ${NC}] ";
    fi
}
 
function stopExaBGP(){
    if [  $PROCESSO -eq 0 ]
    then
        echo -e "ExaBGP não está sendo executado. [${VERMELHO} Parado ${NC}]";
        
    else 
        echo "Parando...";
        kill -9 `cat /var/run/exabgp.pid` &>/dev/null
        echo -e "ExaBGP [${VERMELHO} Parado ${NC}] ";
    fi
}

function statusExaBGP(){
    if [  $PROCESSO -eq 0 ]
    then
        echo -e "ExaBGP está [${VERMELHO} Parado ${NC}]";
    else 
        echo -e "ExaBGP está [${VERDE} Ativo ${NC}]";
    fi
    echo 
    echo "Logs:"
    tail /var/log/exabgp.log
}

case "$1" in
    start )
        startExaBGP
        ;;
 
    stop )
        stopExaBGP
        ;;
 
    restart )
        stopExaBGP
        sleep 1
        startExaBGP
        ;;
 
    status )
        statusExaBGP      
        ;;
 
    * )
        echo "Opção inválida, use start | stop | restart | status"
        ;;
esac

De permissão para execução

# chmod a+x /etc/init.d/exabgp

Crie o arquivo de serviço para o programa exabgp.

# vim /lib/systemd/system/exabgp.service

Adicione

[Unit]
Description=ExaBGP
After=network.target remote-fs.target

[Service]
Type=simple
RemainAfterExit=yes
ExecStart=/etc/init.d/exabgp start
ExecStop=/etc/init.d/exabgp stop
ExecReload=/etc/init.d/exabgp restart
 
[Install]
WantedBy=multi-user.target

Recarregue a nova definição do serviço:

# systemctl daemon-reload

Ative o novo serviço, e verifique se o mesmo foi ativado

# systemctl enable exabgp
# systemctl list-unit-files | grep exabgp

Reinicie seu servidor

# reboot

Verifique se o exabgp foi carregado na inicialização, e seu peer estabilizou.

# systemctl status exabgp

Para iniciar/reiniciar os exabgp pode usar os seguintes comandos:

# systemctl stop exabgp
# systemctl start exabgp
# systemctl restart exabgp

Para acompanhar a coleta de flows use o comando:

# fastnetmon_client

Você vai encontrar tutoriais como integrar com grafana…. mas para mim isso é perfumaria, o mais legal é ver o processamento sem frescura, e saber que pode ser implementado com uma minimo de hardware, essa mesma analise de flows do gráfico assim que está na casa dos 3GBps de tráfego temos o seguinte uso do hasrdware:

Se quiser fazer algum teste, para anunciar uma rotas manualmente user os seguintes comandos:

# echo "announce route 100.101.255.200 next-hop 172.31.31.2 community 65001:666" > /var/run/exabgp.cmd

E para remover:

# echo "withdraw route 100.101.255.200 next-hop 172.31.31.2"  > /var/run/exabgp.cmd

Acordo de communities com sua operadora

Não vai adiantar muito você identificar o IP que está tomando o ataque se você não repassar o mesmo para sua operadora e ela o mesmo. Como você identificou o IP que esta recebendo o ataque (ou ate mesmo atacando) o mesmos vai subir na sua tabela de rotas como tipo blackhole, logo seu roteador não vai mais responder para esse IP. Sim esse IP não terá mais internet (clientes, servidor….) sim não terá! rsrs, por isso é importante receber o alerta, para saber qual medidas realizar. Nas configurações do fastnetmon existe um arquivo de lista branca /etc/networks_whitelist se desejar você pode incluir os IPs que não quer que o fastnetmon analise (logo não ira bani-lo) porém você também não vai saber se ele foi atacado, eu prefiro deixar esse networks_whitelist vazio e criar então um filtro no roteador para descartar os IPs que não quero que ele jogue na blackhole, assim eu sou notificado, e se o bicho realmente estiver pegando eu deixo passar o ip do servidor e penso no que vou fazer hehehe.

As grande operadoras normalmente tem uma politica de communities que aceita você repassar prefixos /32 com a communities onde em quase todos os casos é AS:666 ou 65xxx:666, então o que você precisa fazer é primeira mente entrar em contato com a mesma para pegar essas informações, caso ela não saiba do que você está falando manda esse o link deste tutorial

Bom, vamos imaginar que sua operadora senha o AS28146 (olha o marketing ai de graça/patrocina eu MH) e seu bloco seja 200.200.200.0/22, como ficaria seu filtro no seu MK?

/routing filter
add action=accept  chain=AS28146-IPv4-OUT bgp-communities=65001:666 prefix-length=32 set-bgp-communities=28146:666
add action=accept  chain=AS28146-IPv4-OUT prefix=45.189.228.0/22 prefix-length=22-23
add action=discard chain=AS28146-IPv4-OUT

Explicando a primiera linha:
action=accept –> aceita
chain=AS28146-IPv4-OUT –> nome do seu filtro
bgp-communities=65001:666 -> todas as rotas marcadas com a communities=65001:666 (as q o fastnetmon nos enviou)
prefix-length=32 –> com prefixo apenas /32
set-bgp-communities=28146:666 –> seta a communitie que você verificou com sua operadora

Se você quiser descartar algum IP, ex um servidor (como comentei anteriormente) apenas para a operadora você precisa colocar antes das regras (antes da linha 1). Ex servidor 200.200.200.7 quero descartar para não cair na blackhole:

/routing filter
add action=discard chain=AS28146-IPv4-OUT prefix=45.189.228.7/32 prefix-length=32 
add action=accept  chain=AS28146-IPv4-OUT bgp-communities=65001:666 prefix-length=32 set-bgp-communities=28146:666
add action=accept  chain=AS28146-IPv4-OUT prefix=45.189.228.0/22 prefix-length=22-23
add action=discard chain=AS28146-IPv4-OUT

Agora se você simplesmente não quer que seja bloqueado de forma alguma é só add no filtro do peer com o fastnetmon.

/routing filter
add action=discard chain=FastNetMon-IN prefix=45.189.228.7/32 prefix-length=32
add action=accept  chain=FastNetMon-IN set-type=blackhole
add action=discard chain=FastNetMon-OUT

Seria interessante fazer alguns teste de ataques (coisa pequena) de dentro da sua rede e de fora, escolha uma IP que não esteja em uso para tal! Para realizar esse ataque user o a ferramenta criada pelo ekovegeance:
https://github.com/ekovegeance/DDOS

Em um servidor/desktop linux vai precisar ter instalado os pacotes bash sudo curl netcat hping3 openssl stunnel nmap whois dnsutils.
Baixe os arquivos, extraia entre em sua pasta e execute o arquivo ddos.

$ wget https://github.com/ekovegeance/DDOS/archive/v1.2.4.zip
$ unzip v1.2.4.zip 
$ cd DDOS-1.2.4/
$ ./ddos

Gostou? Se sentindo mais seguro agora?

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.

Abraço!

O post Proteja-se de ataques DoS/DDoS mitigando com FastNetMon e anuncie os prefixos atacados (blackholes) para sua operadora, usando Mikrotik :-) apareceu primeiro em Remontti.

Neste tutorial abordaremos a instalação e configuração do Elastic Stack 7.x, que será usado para alimentar a solução ElastiFlow.

Elastic Stack consiste no Elasticsearch, Logstash e Kibana.
– Elasticsearch é um mecanismo de pesquisa baseado em texto completo.
– Logstash é um mecanismo de coleta de dados e análise de log.
– Kibana é uma plataforma de análise e visualização usada para exibir os painéis do ElastiFlow.
– ElastiFlow fornece coleta e visualização de dados de fluxo de rede usando o Elastic Stack (Elasticsearch, Logstash e Kibana). Suporta os tipos de fluxo Netflow v5/v9, sFlow e IPFIX.

Painéis fornecidos através do ElastiFlow

Visão Global Overview

Top-N
Existem painéis Top-N separados para os principais locutores, serviços, conversas e aplicativos.

Ameaças Threats
O ElastiFlow inclui um dicionário de endereços IP públicos que são conhecidos por terem uma má reputação. Este dicionário é construído a partir de muitas fontes de dados OSINT, normalizadas para uma taxonomia comum. O painel de ameaças usa essas informações de reputação de IP para destacar três tipos de ameaça/risco.
1. Ameaças Públicas – Clientes públicos com baixa reputação de IP que estão atingindo endereços privados.
2. Servidores em Risco – Servidores Privados que estão sendo acessados ​​por clientes com baixa reputação de IP.
3. Clientes de alto risco – Clientes privados que acessam servidores públicos com baixa reputação.

Fluxos Flows
Existem painéis Sankey separados para as perspectivas Cliente/Servidor, Origem/Destino e Sistema Autônomo. As visualizações sankey são construídas usando o novo plugin de visualização Vega.

Geo IP
Existem painéis de Geo localização separados para as perspectivas Cliente/Servidor e Origem/Destino (Dados GeoLite2 criados pela MaxMind, disponíveis em http://www.maxmind.com)

Tráfego por AS AS Traffic
Fornece uma visão do tráfego para e de sistemas autônomos (intervalos de IP públicos)

Exportadores de Fluxo Flow Exporters

Detalhes do Trânsito Traffic Details

Registros de Fluxo Flow Records

Ziften ZFlow
O ElastiFlow adicionou suporte para registros IPFIX do agente ZFlow do ZFlow. Além de estar totalmente integrado aos painéis de controle padrão, os painéis ZFlow independentes exibem o tráfego de rede com base nos dados de usuário e de comando fornecidos pelo ZFlow.

Requisitos de Hardware.

Meus testes foram realizado em meu computador com VM no Virtualbox sendo 4 CPUs (i7) e 8GB de RAM

E o bixinho levou um pau!

Vou utilizar o Debian 10 instalado de forma “limpa”, sem nenhum outro pacote, para isso siga o tutorial:
Instalação Debian 10 Buster LIMPA Passo-a-passo

Com seu Debian 10 instalado acesse o mesmo e vire root!

# su - 

Instale os pacotes básicos necessários

# apt install wget apt-transport-https gnupg unzip curl net-tools

Recomendo a instalacao dos firmwares binário para vários drivers do kernel Linux, para isso adicione contrib non-free ao seu repositório.

# vim /etc/apt/sources.list

deb http://deb.debian.org/debian/ buster main contrib non-free
deb-src http://deb.debian.org/debian/ buster main contrib non-free

deb http://security.debian.org/debian-security buster/updates main contrib non-free
deb-src http://security.debian.org/debian-security buster/updates main contrib non-free

deb http://deb.debian.org/debian/ buster-updates main contrib non-free
deb-src http://deb.debian.org/debian/ buster-updates main contrib non-free

# apt update
# apt install firmware-linux firmware-linux-free firmware-linux-nonfree

Reinicie para que os novos módulos sejam carregado.

# reboot

:: Elastic Stack 7 ::

Será necessário ter o Java instalado.

# su -
# apt install default-jre

Adicione o repositório elastic.

# wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
# echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" |  tee -a /etc/apt/sources.list.d/elastic-7.x.list
# apt update

Faremos a instalação individual dos pacotes elasticsearch, kibana e logstash.

:: Elasticsearch ::

Elasticsearch é um mecanismo de pesquisa baseado em texto completo.

# apt install elasticsearch

Após instalação vamos alterar network.host para ouvir apenas localhost, em seguida ativar o serviço e inicia-lo.

# sed -i 's/#network.host: 192.168.0.1/network.host: 127.0.0.1/' /etc/elasticsearch/elasticsearch.yml
# systemctl daemon-reload
# systemctl enable elasticsearch
# systemctl start elasticsearch

Cheque se o mesmo esta funcionando

# curl -X GET 127.0.0.1:9200

Retorno algo como….

{
  "name" : "lab",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "-U7i4KbKSxSgChHSxMpcfg",
  "version" : {
    "number" : "7.3.0",
    "build_flavor" : "default",
    "build_type" : "deb",
    "build_hash" : "de777fa",
    "build_date" : "2019-07-24T18:30:11.767338Z",
    "build_snapshot" : false,
    "lucene_version" : "8.1.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

Caso o comando `curl -X GET 127.0.0.1:9200` retorne algum erro, tente verificar se o serviço esta rodando com o comando `systemctl status elasticsearch`. Verifique nos logs `tail -f /var/log/elasticsearch/elasticsearch.log`se o erro aparece:

Failure running machine learning native code. 
This could be due to running on an unsupported OS or distribution, missing OS libraries, 
or a problem with the temp directory. To bypass this problem by running 
Elasticsearch without machine learning functionality set [xpack.ml.enabled: false]."

Se o mesmo aparecer execute o comando:

# echo "xpack.ml.enabled: false" >> /etc/elasticsearch/elasticsearch.yml
# systemctl restart elasticsearch

:: kibana ::

Kibana é uma plataforma de análise e visualização usada para exibir os painéis do ElastiFlow.

# apt install kibana

Após instalação vamos alterar server.host, em seguida ativar o serviço e inicia-lo.

# sed -i 's/#server.host: "localhost"/server.host: "0.0.0.0"/' /etc/kibana/kibana.yml
# systemctl daemon-reload
# systemctl enable kibana
# systemctl start kibana

Aguarde um pouco o serviço iniciar e já será possível acessar Kibana em seu navegador:
http://[IP-SERVIDOR]:5601

:: logstash ::

O Logstash é um mecanismo de coleta de dados e análise de log.

# apt install logstash

Para aumentar o desempenho o ElastiFlow aproveita os recursos de cache e enfileiramento disponíveis em muitos dos plugins do Logstash. Esses recursos aumentam o consumo do heap da JVM. O espaço de heap da JVM usado pelo Logstash é configurado em jvm.options. Recomenda-se que o Logstash receba pelo menos 2GB de heap da JVM. Se todas as opções, incl. Pesquisas DNS estão habilitadas aumente para 4GB. Defina o tamanho de heap da JVM.

# vim /etc/logstash/jvm.options

Altere de a cordo com a necessidades. No meu caso vou resolver nomes então vou usar 4gb

-Xms4g
-Xmx4g

Instale e atualize os plugins necessários pelo Logstash. Para usar o ElastiFlow, você precisará instalar o codec sFlow suportado pela comunidade para o Logstash. Também é recomendável que você sempre use a versão mais recente do codec Netflow, a entrada UDP e o filtro DNS. Isso pode ser conseguido executando os seguintes comandos:

# /usr/share/logstash/bin/logstash-plugin install logstash-codec-sflow --no-verify
# /usr/share/logstash/bin/logstash-plugin update logstash-codec-netflow --no-verify
# /usr/share/logstash/bin/logstash-plugin update logstash-input-udp --no-verify
# /usr/share/logstash/bin/logstash-plugin update logstash-input-tcp --no-verify
# /usr/share/logstash/bin/logstash-plugin update logstash-filter-dns --no-verify
# /usr/share/logstash/bin/logstash-plugin update logstash-filter-geoip --no-verify
# /usr/share/logstash/bin/logstash-plugin update logstash-filter-translate --no-verify
# /usr/share/logstash/bin/logstash-plugin install --no-verify

# /usr/share/logstash/bin/logstash-plugin install logstash-codec-sflow
# /usr/share/logstash/bin/logstash-plugin update logstash-codec-netflow
# /usr/share/logstash/bin/logstash-plugin update logstash-input-udp
# /usr/share/logstash/bin/logstash-plugin update logstash-input-tcp
# /usr/share/logstash/bin/logstash-plugin update logstash-filter-dns
# /usr/share/logstash/bin/logstash-plugin update logstash-filter-geoip
# /usr/share/logstash/bin/logstash-plugin update logstash-filter-translate

:: elastiflow ::

ElastiFlow fornece coleta e visualização de dados de fluxo de rede usando o Elastic Stack (Elasticsearch, Logstash e Kibana). Suporta os tipos de fluxo Netflow v5/v9, sFlow e IPFIX.

# mkdir /root/flowinstall
# cd /root/flowinstall
# wget https://github.com/robcowart/elastiflow/archive/master.zip
# unzip master.zip
# mv elastiflow-master/logstash/elastiflow/  /etc/logstash/
# mv elastiflow-master/logstash.service.d/ /etc/systemd/system/
# cp /etc/logstash/logstash-sample.conf  /etc/logstash/logstash.conf

Adicione o pipeline ElastiFlow aos pipelines.yml

# vim  /etc/logstash/pipelines.yml

Adicione ao final:

- pipeline.id: elastiflow
  path.config: "/etc/logstash/elastiflow/conf.d/*.conf"

Também defino ELASTIFLOW_RESOLVE_IP2HOST como true e defino meu servidor DNS em ELASTIFLOW_NAMESERVER para que os painéis tentem resolver os nomes DNS em vez de exibir apenas o endereço IP. Há um impacto no desempenho por isso será necessário ter RAM sobrando!
Neste exemplo vou aplicar a resolução de nomes.

# sed -i 's/ELASTIFLOW_RESOLVE_IP2HOST=false/ELASTIFLOW_RESOLVE_IP2HOST=true/' /etc/systemd/system/logstash.service.d/elastiflow.conf
# sed -i 's/ELASTIFLOW_NAMESERVER=127.0.0.1/ELASTIFLOW_NAMESERVER=1.1.1.1/' /etc/systemd/system/logstash.service.d/elastiflow.conf

Se desejar pode editar o arquivo /etc/systemd/system/logstash.service.d/elastiflow.conf
E alterar as opções conforme suas necessidades. Os dois comandos acima alteram:
ELASTIFLOW_RESOLVE_IP2HOST=true
ELASTIFLOW_NAMESERVER=1.1.1.1

Vamos configurar os arquivos init (system-install) em seguida ativar o serviço para inicialização e starta-lo.

# systemctl daemon-reload
# /usr/share/logstash/bin/system-install
# systemctl enable logstash
# systemctl start logstash

Precisamos configurar os índices do elastiflow-*padrão, execute o seguinte comando:

Atualização: O projeto da data de hoje (20/03/2020) está da versão 7.6.x e em suas releases https://github.com/robcowart/elastiflow/releases alguns arquivos não parecem mais estarem lá, uma das “gambi” é pegar esses arquivos de commits antigas. Vamos precisar deles -> elastiflow.tar.gz (boa sorte)

# cd /root/flowinstall
# wget https://blog.remontti.com.br/wp-content/uploads/2019/08/elastiflow.tar.gz
# tar vxf elastiflow.tar.gz 
# curl -X POST http://127.0.0.1:5601/api/saved_objects/index-pattern/elastiflow-* -H "Content-Type: application/json" -H "kbn-xsrf: true" -d @elastiflow.index_pattern.json

O arquivo JSON contém a configuração do padrão de índice.

Agora o arquivo elastiflow.kibana.7.0.x.json deveria estar em https://github.com/robcowart/elastiflow/tree/master/kibana mas não está rsrsrs então baixe ele aqui elastiflow.kibana.7.0.x e extraia ele no seu computador. (peguei ele la da v.3.5.1)

Porém Hoje 31/03/2020 utilizando o arquivo elastiflow.kibana.7.5.x.ndjson deu certo, entao tente importar ele, caso contrario tente o citado acima (P* zona não seguem um padrão fica foda do cara dizer algo rsrsrs) (Versão testada 7.6.1)

Para que os painéis possam ser carregados no Kibana, importando o elastiflow.kibana.7.0.x.json. Isso é feito a partir do menu Management -> Saved Objects. Abra o kibana

Configurações Avançadas Recomendadas do Kibana

Modificar algumas das configurações avançadas do Kibana produzirá uma experiência mais amigável ao usar o ElastiFlow. Essas configurações são feitas em Kibana, abaixo Management -> Advanced Settings.

doc_table:highlight

Há uma penalidade de desempenho de consulta muito grande que vem com o uso do recurso de destaque. Como não é muito útil para este caso de uso, é melhor simplesmente retirá-lo.

filters:pinnedByDefault

Fixar um filtro permitirá que ele persista quando você está mudando de dashbaords. Isso é muito útil ao detalhar algo interessante e você deseja alterar os painéis para uma perspectiva diferente dos mesmos dados. Este é o primeiro cenário que mudo sempre que estou trabalhando com o Kibana.

state:storeInSessionStorage

Os URLs do Kibana podem ficar muito grandes. Especialmente quando se trabalha com visualizações Vega. Isso provavelmente resultará em mensagens de erro para usuários do Internet Explorer. Usar o armazenamento na sessão corrigirá esse problema para esses usuários.

timepicker:quickRanges

As opções padrão no Seletor de Tempo são menos que ideais, para a maioria dos casos de uso de registro e monitoramento. Felizmente, o Kibana agora permite que você personalize o selecionador de tempo. Nossas configurações recomendadas podem ser encontradas abaixo.

[
  {
    "from": "now-15m",
    "to": "now",
    "display": "Last 15 minutes"
  },
  {
    "from": "now-30m",
    "to": "now",
    "display": "Last 30 minutes"
  },
  {
    "from": "now-1h",
    "to": "now",
    "display": "Last 1 hour"
  },
  {
    "from": "now-2h",
    "to": "now",
    "display": "Last 2 hours"
  },
  {
    "from": "now-4h",
    "to": "now",
    "display": "Last 4 hours"
  },
  {
    "from": "now-12h",
    "to": "now",
    "display": "Last 12 hours"
  },
  {
    "from": "now-24h",
    "to": "now",
    "display": "Last 24 hours"
  },
  {
    "from": "now-48h",
    "to": "now",
    "display": "Last 48 hours"
  },
  {
    "from": "now-7d",
    "to": "now",
    "display": "Last 7 days"
  },
  {
    "from": "now-30d",
    "to": "now",
    "display": "Last 30 days"
  },
  {
    "from": "now-60d",
    "to": "now",
    "display": "Last 60 days"
  },
  {
    "from": "now-90d",
    "to": "now",
    "display": "Last 90 days"
  },
  {
    "from": "now/d",
    "to": "now/d",
    "display": "Today"
  },
  {
    "from": "now/w",
    "to": "now/w",
    "display": "This week"
  },
  {
    "from": "now/M",
    "to": "now/M",
    "display": "This month"
  },
  {
    "from": "now/d",
    "to": "now",
    "display": "Today so far"
  },
  {
    "from": "now/w",
    "to": "now",
    "display": "Week to date"
  },
  {
    "from": "now/M",
    "to": "now",
    "display": "Month to date"
  }
]

Por padrão, os dados de fluxo serão recebidos nas portas padrão para cada tipo de fluxo. Você pode alterar os IPs e as portas usadas modificando as seguintes variáveis em /etc/systemd/system/logstash.service.d/elastiflow.conf.

Se tiver alguma dificuldade verifique os logs do logstash:

# tail -f /var/log/logstash/logstash-plain.log

Use também o tcpdum para verificar se seu roteador está enviando os flows.

Se você instalou não quer atualizar com medo de algum “BO” recomendo você desativar o repositório do elastic:

# vim /etc/apt/sources.list.d/elastic-7.x.list

Comente “# deb https://artifacts.elastic.co/packages/7.x/apt stable main”

Portas Padrões
Netflow – IPv4: 2055
Netflow – IPv6: 52055
sFlow – IPv4: 6343
sFlow – IPv6: 56343
IPFIX – IPv4: 4739
IPFIX – IPv6: 54739
Pode ser alterado

BÔNUS – Enviando dados do RouterOS/Mikrotik

Onde ether1 é a interface que vai ser monitorada, no meu caso estou coletando 4k, isso vai depender muito do hardware da sua máquina, e 200.200.200.200 seria o IP do nosso servidor.

/ip traffic-flow
set cache-entries=4k enabled=yes interfaces=ether1
/ip traffic-flow target
add dst-address=200.200.200.200 version=5

Como não tem restrição ao acesso a porta 5601 é interessante você aplicar um firewall em seu servidor
Modelo simples e funcional de Firewall com iptables

Parabéns! Você concluiu! Gostou?

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.

Abraço!

Fonte:
https://github.com/robcowart/elastiflow/blob/master/INSTALL.md
https://www.elastic.co/guide/en/kibana/current/deb.html

O post Instalação do Elastic Stack 7 + ElastiFlow no Debian 10 Buster (Bônus Traffic Flow Mikrotik/RouterOS) apareceu primeiro em Remontti.

Antes de mais nada vamos Rsyslog é o sistema de log padrão no Debian depois da versao 8 Lenny, substituto para o antigo syslog. Rsyslog conta com suporte para login em bancos de dados (MySQL e PostgreSQL). A configuração usa o dbconfig-common para facilitar a configuração via debconf.

Distribuição testadas:
Debian 11
Debian 10
Debian 9

Não precisa ser instalado nenhum pacote, apenas ter nosso Debian instalado. Vamos lá!

# vim /etc/rsyslog.conf

Neste arquivo descomente as linhas module(load=”imudp”) & input(type=”imudp” port=”514″). Se preferir você pode alterar a porta padrão 514, no exemplo vou alterar para 65014.

	# provides UDP syslog reception
	module(load="imudp")
	#input(type="imudp" port="514")
	input(type="imudp" port="65014")

Criamos o template que va ireceber os logs remoto e ignoramos os logs de localhost. Para que fique organizados vamos gerar um arquivo de log para cado Host/IP dentro do diretório /var/log/minharede/

# vim /etc/rsyslog.d/minharede.conf

$template RemoteHost,"/var/log/minharede/%HOSTNAME%.log
:fromhost-ip, !isequal, "127.0.0.1"    ?RemoteHost

Reiniciamos o serviço

# systemctl restart rsyslog

Verifique se a porta esta aberta

# netstat -putan | grep 65014

Vamos configurar o logrotate para fazer a compressão a cada 7 dias. Você tabém não precisa instalar o pacote pois ele já padrão do sistema.
O logrotate é projetado para simplificar a administração de arquivos de log em um sistema que gera um monte de arquivos de log. O logrotate possibilita a compressão rotativa automática. O logrotate pode ser configurado para manipular um arquivo de log diariamente, semanalmente, mensalmente ou quando o arquivo de log atingir um certo tamanho.

Criaremos o arquivo /etc/logrotate.d/minharede

# vim /etc/logrotate.d/minharede

/var/log/minharede/*.log {
    monthly
    rotate 12
    missingok
    notifempty
    sharedscripts
    postrotate
    /bin/kill -HUP `cat /var/run/syslogd.pid 2> /dev/null` 2> /dev/null || true
    endscript
}

Para testar execute o comando:

# logrotate /etc/logrotate.d/minharede --debug

reading config file /etc/logrotate.d/minharede
Reading state from file: /var/lib/logrotate/status
Allocating hash table for state file, size 64 entries

rotating pattern: /var/log/minharede/*.log after 1 days (7 rotations)
empty log files are not rotated, old logs are removed
considering log /var/log/minharede/r1.log
Creating new state
Now: 2018-09-06 14:49
Last rotated at 2018-09-06 14:00
log does not need rotating (log has been already rotated)
not running postrotate script, since no logs were rotated

Configurando syslog no RouterOS/Mikoritk

Configure seu agora em seus roteadores

/system logging action
add name=RouterLog remote=250.250.250.2 remote-port=65014 target=remote

/system logging
add action=RouterLog topics=info
add action=RouterLog topics=warning
add action=RouterLog topics=critical
add action=RouterLog topics=error

Configurando syslog no Huawei

info-center channel 6 name logserver
info-center source default channel 6 log level informational
info-center loghost source LoopBack0
info-center loghost 250.250.250.2 channel 6 facility local2 port 65014

Agora pode verificar no diretório os arquivos de logs estarão sendo criado.

# ls -lh /var/log/minharede/

Ex para acompanhar o log em tempo real onde r1.log seria o nome do arquivo criado.

# tail -f /var/log/minharede/r1.log

Recomendado ter um firewall nesta porta para deixar apenas IPs de seus roteadores ter acesso.
Neste link tenho um modelo simples e funcional de Firewall com iptables

Gostou? Deixe seu comentário ficarei feliz em saber que lhe ajudei, e se tiver qualquer pergunta deixe-a também, se preferir acesse o menu Consultoria lá você encontra meios de falar comigo!

Abraço!

O post Servidor de log para registros remoto do RouterOS/Mikrotik Huawei entre outros fabricantes apareceu primeiro em Remontti.