Arquivos Huawei - Remontti

Aprenda a instalar um dos melhores Looking Glasses de código aberto: o Hyperglass

Rudimar Remontti — Thu, 30 Mar 2023 13:56:07 +0000

O que é o Hyperglass

O hyperglass é um espelho de rede de código aberto escrito por um engenheiro de rede para outros engenheiros de rede. O objetivo de um espelho é fornecer aos clientes, colegas e completos estranhos uma visibilidade autônoma da rede de uma operadora. A hyperglass foi criada com o grande objetivo de beneficiar a comunidade da Internet em geral, fornecendo uma maneira mais rápida, fácil e segura para as operadoras fornecerem serviços de espelhos a seus clientes, colegas e outras operadoras de rede.

Recursos:
– Rota BGP
– BGP Community
– BGP AS Path
– Ping
– Traceroute

Suporte para:
– Arista EOS
– BIRD
– Cisco IOS-XR
– Cisco IOS/IOS-XE
– Cisco NX-OS
– FRRouting
– Huawei
– Juniper JunOS
– Mikrotik
– Nokia SR OS
– TNSR
– VyOS

Personalização recursos, tema, texto da UI/API, mensagens de erro e comandos.

Ao decorrer do tutorial irei deixar todos os links com referencia a documentação https://hyperglass.dev/docs/, pois o mesmo tem muita possibilidades.

Notas e agradecimento

O hyperglass é tem sua principal base desenvolvida em Python e está disponível no github.com por thatmattlove, no entanto conta com um grupo no telegram onde encontrei algumas soluções para huawei, meu conhecimento em Python é limitado (ainda), mas criei meu próprio fork do projeto, e realizei algumas alterações. Deixar aqui uma agradecimento a eaitelecomunicacoes onde encontrei uma contribuição que me ajudou muito. Contamos com ajuda de todos para tornar o projeto algo ainda melhor! Se tiver melhorias nao deixe de realizar um Pull requests.

Distribuição Linux

Todos meus testes foram realizando em cima do Debian 11
– Instalação do Debian 11 Bullseye limpa passo-a-passo

Acesse seu servidor e se torne root da forma correta:

# su -

Pacotes necessários

# apt install -y python3-dev python3-pip python3-pil python3-pil.imagetk\
 python3-libtiff python3-glymur libtiff-dev libfreetype-dev liblcms2-2\
 liblcms2-utils libwebp-dev libboost-dev libimagequant-dev libraqm-dev\
 libjpeg-dev wget unzip zip git curl gnupg2

Script de instalação

# cd /tmp
# wget https://raw.githubusercontent.com/remontti/hyperglass/main/install.sh
# bash install.sh

Ao finalize execute o comando hyperglass –help para ver se a instalação esta funcionando.

# hyperglass --help

Usage: hyperglass [OPTIONS] COMMAND [ARGS]...

   hyperglass Command Line Interface

Options:
   -v, --version   hyperglass version
   -h, --help      Show this help message

Commands:
   build-ui      Create a new UI build
   clear-cache   Clear the Redis cache
   secret        Generate agent secret
   setup         Run the setup wizard
   start         Start web server
   system-info    Get system information for a bug report

Configurando hyperglass

# hyperglass setup

Vamos definir o diretório de configurações, selecione com a seta para baixo /etc/hyperglass

[?] Choose a directory for hyperglass: /etc/hyperglass
   /root/hyperglass
 > /etc/hyperglass

Antes de deixar você chanar no erro webpack:

[ERROR] 20230330 10:02:32 | hyperglass.util.frontend:401 | build_frontend → 
Messages:
info  - Using webpack 5. Reason: future.webpack5 option enabled https://nextjs.org/docs/messages/webpack5

Vamos a solução localize `webpack5: true,` e altere para `webpack5: false,`

# sed -i 's/webpack5: true,/webpack5: false,/g' /usr/local/lib/python3.9/dist-packages/hyperglass/ui/next.config.js

Parâmetros de configuração

Crie o arquivo /etc/hyperglass/hyperglass.yaml

# vim /etc/hyperglass/hyperglass.yaml

Ajuste suas informações. Doc.

# https://hyperglass.dev/docs/parameters
debug: false
developer_mode: false
org_name: Remontti Telecom
primary_asn: 12345
site_title: Looking Glass Remontti
site_description: "{org_name} Network Looking Glass"
site_keywords: [hyperglass, looking glass, routing, bgp]
request_timeout: 30
listen_address: "172.18.18.79"  # IP que ira startar o serviço
listen_port: 80  # Porta do servico
#
# https://hyperglass.dev/docs/response-caching
cache:
  database: 0
  host: localhost
  port: 6379
  show_text: true
  timeout: 120
#
# https://hyperglass.dev/docs/messages/
messages:
  acl_denied: "{target} is a member of {denied_network}, which is not allowed."
  acl_not_allowed: "{target} is not allowed."
  authentication_error: Authentication error occurred.
  connection_error: "Error connecting to {device_name}: {error}"
  feature_not_enabled: "{feature} is not enabled for {device_name}."
  general: Something went wrong.
  invalid_field: "{input} is an invalid {field}."
  invalid_input: "{target} is not a valid {query_type} target."
  no_input: "{field} must be specified."
  no_output: The query completed, but no matching results were found.
  no_response: No response.
  parsing_error: An error occurred while parsing the query output.
  request_timeout: Request timed out.
  vrf_not_associated: VRF {vrf_name} is not associated with {device_name}.
  vrf_not_found: VRF {vrf_name} is not defined.
#
# https://hyperglass.dev/docs/logging/ (/var/log/hyperglass.log)
logging:
  directory: /var/log
  format: text
  max_size: 50 MB
#
# https://hyperglass.dev/docs/query-settings/
queries:
  bgp_route:
    display_name: BGP Route
    enable: true
  bgp_community:
    #Huwei modo structured não fuciona
    display_name: BGP Community
    enable: false
    mode: select
    communities:
      - community: 12345:666
        display_name: Blackhole
        description: 12345:666
  bgp_aspath:
    #Huwei modo structured não fuciona
    display_name: BGP AS Path
    enable: false
    pattern:
      asdot: '^(\^|^\_)((\d+\.\d+)\_|(\d+\.\d+)\$|(\d+\.\d+)\(\_\.\+\_\))+$'
      asplain: '^(\^|^\_)(\d+\_|\d+\$|\d+\(\_\.\+\_\))+$'
      mode: asplain
  ping:
    display_name: Ping
    enable: true
  traceroute:
    display_name: Traceroute
    enable: true
    #
# https://hyperglass.dev/docs/table-output/
structured:
  rpki:
    mode: external

#  communities:
#    #Para não exibir nenhuma communities    
#    mode: deny

#  communities:
#    # Para permitir apenas...
#    mode: permit
#    items:
#      - '65000:\d+'
#      - '65[1-4]00:\d+'

# https://hyperglass.dev/docs/ui/configuration/
web:
  links:
    - title: PeeringDB
      url: https://www.peeringdb.com/asn/12345
      side: left
      order: 1
    - title: Qrator
      url: https://radar.qrator.net/AS12345
      side: left
      order: 2
    - title: RADb
      url: https://www.radb.net/query?advanced_query=&keywords=AS12345
      side: left
      order: 3
    - title: IRR Explorer
      url: https://irrexplorer.nlnog.net/asn/AS12345
      side: left
      order: 4
    - title: RDAP
      url: https://rdap.registro.br/autnum/12345
      side: left
      order: 5    
    - title: Remontti
      url: https://www.remontti.com.br
      side: right
      order: 0
  menus:
    - title: Contato
      content: "Please contact [noc@remontti.com.br](mailto:noc@remontti.com.br) to get support."
      side: right
    - title: Termos e Condições
      content: /etc/hyperglass/terms-and-conditions.md
      side: right
  # https://hyperglass.dev/docs/ui/logo
  logo:
    dark: /etc/hyperglass/static/images/hyperglass-dark.svg
    light: /etc/hyperglass/static/images/hyperglass-light.svg
    favicon: /etc/hyperglass/static/images/hyperglass-icon.svg
    height: null
    width: 100%
  # https://hyperglass.dev/docs/ui/text
  text:
    cache_icon: Cached from {time} UTC
    cache_prefix: "Results cached for "
    complete_time: Completed in {seconds}
    fqdn_error: Unable to resolve {fqdn}
    fqdn_error_button: Try Again
    fqdn_message: Your browser has resolved {fqdn} to
    fqdn_tooltip: Use {protocol}
    no_communities: No Communities
    query_location: Location
    query_target: Target
    query_type: Query Type
    query_vrf: Routing Table
    rpki_invalid: Invalid
    rpki_unknown: No ROAs Exist
    rpki_unverified: Not Verified
    rpki_valid: Valid
    subtitle: Network Looking Glass
    title: hyperglass
    title_mode: logo_subtitle
  # https://hyperglass.dev/docs/ui/theme
  # https://hyperglass.dev/docs/ui/example

Adicionando Dispositivos

Para adicionar seus dispositivos para cunsultas LG, crie o arquivo /etc/hyperglass/devices.yaml. Vou deixar um exemplo básico para Huawei, Mikrotik e comando personalizados com Linux. Docs

# vim /etc/hyperglass/devices.yaml

Adicione de acordo suas configurações

# https://hyperglass.dev/docs/adding-devices
routers:
  - name: AS12345 Remontti
    address: 10.50.50.25
    network:
      name: as12345
      display_name: Huawei
    credential:
      username: lookingglass
      password: supersenha
    port: 22
    nos: huawei
    vrfs:
      - name: global
        default: true
        ipv4:
          source_address: 200.200.200.200
          access_list:
            - network: 10.0.0.0/8
              action: deny
            - network: 192.168.0.0/16
              action: deny
            - network: 100.64.0.0/10
              action: deny
            - network: 172.16.0.0/12
              action: deny
            - network: 0.0.0.0/0
              action: permit
              ge: 8
              le: 32
        ipv6:
          source_address: 2000:2000:1::1
          access_list:
            - network: ::/0
              action: permit
              ge: 32
              le: 128

  - name: Mkzao Remontti
    address: 172.18.18.1
    network:
      name: routerosrr
      display_name: Mikrotik
    credential:
      username: usuario
      password: senha
    port: 22
    nos: mikrotik_routeros
    vrfs:
      - name: global
        default: true
        ipv4:
          source_address: 172.18.18.1
        ipv6:
          source_address: 2001:db8::2

  - name: Localhost Hyperglass
    address: 127.0.0.1
    network:
      name: test1
      display_name: Linux
    credential:
      username: usuario
      password: senha
    nos: linux
    commands: linux_comando_personlizado
    vrfs:
      - name: global
        default: true
        ipv4:
          source_address: 192.168.0.5
        ipv6:
          source_address: 2001:db8:bebe:cafe:5

Comandos personalizados

# vim /etc/hyperglass/commands.yaml

Acima adicionei um device linux, qual temos comandos personalizado, segue um exemplo de como seria. Crie o arquivo /etc/hyperglass/commands.yaml

#https://hyperglass.dev/docs/commands
linux_comando_personlizado:
  ipv4_default:
    bgp_route: 'echo bgp_route "{target}"'
    bgp_aspath: 'echo bgp_aspath "{target}"'
    bgp_community: 'echo bgp_community "{target}"'
    ping: 'ping -c 4 "{target}"'
    traceroute: 'traceroute -n "{target}"'
  ipv6_default:
    bgp_route: 'echo "{target}"'
    bgp_aspath: 'echo "{target}"'
    bgp_community: 'echo "{target}"'
    ping: 'echo "{target}"'
    traceroute: 'echo "{target}"'
  ipv4_vpn:
    bgp_route: 'echo "{vrf} {target}"'
    bgp_aspath: 'echo "{vrf} {target}"'
    bgp_community: 'echo "{vrf} {target}"'
    ping: 'echo "{vrf} {target}"'
    traceroute: 'echo "{vrf} {target}"'
  ipv6_vpn:
    bgp_route: 'echo "{vrf} {target}"'
    bgp_aspath: 'echo "{vrf} {target}"'
    bgp_community: 'echo "{vrf} {target}"'
    ping: 'echo "{vrf} {target}"'
    traceroute: 'echo "{vrf} {target}"'

Crie um arquivo para seis termos:

# vim /etc/hyperglass/terms-and-conditions.md

Descreva de acordo suas políticas.

Ao usar {site_title}, você concorda em cumprir os seguintes termos de uso:

Todas as consultas executadas nesta página são registradas para análise e solução de problemas. 
Os usuários estão proibidos de automatizar consultas ou tentar processar consultas em massa. Este serviço é fornecido com base no melhor esforço, e {org_name} não oferece garantias ou garantias de disponibilidade ou desempenho.

Agora vamos a construção da interface do usuário. o Comando a baixo pode levar uns minutinho.

# cd /etc/hyperglass/
# hyperglass build-ui

Aguarde até ter a resposta:

[SUCCESS] 20230329 21:36:48 | hyperglass.util.frontend:386 | build_frontend → Completed UI build
 Completed UI build in production mode

Iniciando o serviço

Poderíamos iniciar com o comando `hyperglass start`, mas vamos criar um serviço no linux para fazer esse trabalho, para deixar até mesmo automatizado durante o boot. para isso irei criar uma pasta /etc/hyperglass/service/ onde irei criar nosso serviço.

# mkdir /etc/hyperglass/service/
# vim /etc/hyperglass/service/hyperglass.service

Agora vamos instruir o que deve ser feito.

[Unit]
Description=hyperglass
After=network.target
Requires=redis-server.service

[Service]
User=root
Group=root
ExecStart=/usr/local/bin/hyperglass start
ExecStop=/usr/bin/pkill -f hyperglass

TimeoutStartSec=120
TimeoutStopSec=300

[Install]
WantedBy=multi-user.target

Vamos cria um apontamento, recarecar nosso daemon, dar um enable para deixar iniciando com o boot, em seguida vamos iniciar o serviço.

# ln -s /etc/hyperglass/service/hyperglass.service /etc/systemd/system/hyperglass.service
# systemctl daemon-reload
# systemctl enable hyperglass 
# systemctl start hyperglass
# systemctl status hyperglass

Pode levar um minutinho até iniciar, você pode acompanhar os logs.

# tail -f /var/log/hyperglass.log

Quando aparecer a mensagem a baixo você pode acessar em seu navegador:

...Started hyperglass 1.0.4 on http://SEUIP:PORTA with 6 workers

Pode verificar também as portas que estão sendo ouvidas.

# ss -putan  | grep LISTEN | grep hyperglass

Acesse me seu navegador http://SEUIP:PORTA

Bonus: Proxy Nginx + Https

É bem comum querer executar o hyperglass em outra porta e somente para localhost, e criar um proxy para acesso web bem como ativar suporte https para sua página, pois em alguns casos ele pode esta rodando junto com outros serviços sem problema algum. Não é necessário ter uma “VM” só para isso. Vamos ao exemplo

# vim /etc/hyperglass/hyperglass.yaml

Altere o IP em listen_address para nosso endereço da loopback 127.0.0.1 e defina outra porta listen_port que ira rodar o serviço, no meu caso vou usar 58000

listen_address: "127.0.0.1"
listen_port: 58000

Reinicie o hyperglass

systemctl restart hyperglass

Instale o Nxgix

# apt install nginx
# sed -i 's/# server_tokens/server_tokens/' /etc/nginx/nginx.conf

Em alguns caso recomendo deletar as conf padrões, caso tiver problemas.

# rm /etc/nginx/sites-enabled/default

Crie um arquivo de configuração o nginx criar um proxy do nosso hyperglass

# vim /etc/nginx/sites-available/hyperglass.conf

Adicione

server {
  listen 80;
  listen [::]:80;
  server_name lg.remontti.com.br;
  #server_name _;

  # Descomente para deixar restrito apenas para determinados prefixos ou IPs.
  #allow  192.168.87.0/24;
  #allow  127.0.0.1;
  #allow  2001:0db8::/32;
  #allow  ::1;
  #deny   all;
  #error_page  403   http://www.remontti.com.br;

  client_max_body_size 2M;
  root /etc/hyperglass/static;

  location / {
    try_files $uri $uri/ /ui /ui/$uri =404;
    index /ui/index.html;
  }

  location /openapi.json {
      try_files $uri @proxy_to_app;
  }

  location /custom/ {
      try_files $uri $uri/ /custom;
  }

  location /images/ {
      try_files $uri $uri/ /images;
  }

  location /api {
      try_files $uri @proxy_to_app;
  }

  location @proxy_to_app {
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header Host $http_host;
    proxy_redirect off;
    proxy_pass http://127.0.0.1:58000;
  }
}

Link o arquivo no diretório /etc/nginx/sites-enabled qual será carregado ao iniciar o nginx, em seguira reinicie o serviço do nginx.

# ln -s /etc/nginx/sites-available/hyperglass.conf /etc/nginx/sites-enabled/hyperglass.conf
# systemctl restart nginx

Agora você já pode acessar seu hyperglass através do nginx.

Criando certificado

Ao executar o Certbot instalado via apt tive alguns erros do python, acredito que conflitou alguma coisa com o hyperglass, (como meu tempo é bem curto inclusive para esta escrevendo aqui) realizei a instalação via snap qual resolveu meu problema.
Segue a instalação do snap:

# apt install snapd
# snap install core

Instale o certbot via snap, crie um link em nossos binários, em seguida execute ele.

# snap install --classic certbot
# ln -s /snap/bin/certbot /usr/bin/certbot
# certbot

Informe os dados, ao finalizar o mesmo irá já ajustar seu arquivo do nginx, e basta acessar seu domínio.

Não esqueça que a cada 90 dias o certificado expira, então crie uma rotina para renovação, você pode adicionar ao cron agendando por exemplo para todo dia primeiro tentar renovar.

# echo '00 00   1 * *   root     certbot renew -q' >> /etc/crontab
# systemctl restart cron

Parabéns você finalizou! 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.

Prints

Abraço!

Fontes:
https://hyperglass.dev/
https://hyperglass.dev/docs/

O post Aprenda a instalar um dos melhores Looking Glasses de código aberto: o Hyperglass apareceu primeiro em Remontti.

Aprenda instalar o ElastiFlow, uma poderosa ferramenta para análise de tráfego de rede no Debian 11 Bullseye

Rudimar Remontti — Thu, 10 Mar 2022 18:29:24 +0000

Coletor de fluxo unificado ElastiFlow
O ElastiFlow Unified Flow Collector recebe, decodifica, transforma, normaliza, traduz e enriquece registros de fluxo de rede e telemetria enviados de dispositivos e aplicativos de rede usando IPFIX, Netflow e sFlow. Os registros resultantes podem ser enviados para diversas plataformas e serviços.

Requisitos de sistema acesse aqui.

Com seu Debian 11 (Bullseye) 64 bits. Instalação mínima pronta

Existem outras formas de configurar, mas aqui tentei passar a forma mais simples possível para que qualquer um consiga insta-lo.

# 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/ 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

# bullseye-updates, to get updates before a point release is made;
# see https://www.debian.org/doc/manuals/debian-reference/ch02.en.html#_updates_and_backports
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

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

Tuning no kernel

# echo "vm.swappiness=10" >> /etc/sysctl.conf
# echo "vm.max_map_count=262144" > /etc/sysctl.d/70-elasticsearch.conf
# cat </etc/sysctl.d/60-net.conf
net.core.netdev_max_backlog=4096
net.core.rmem_default=262144
net.core.rmem_max=67108864
net.ipv4.udp_rmem_min=131072
net.ipv4.udp_mem=2097152 4194304 8388608
EOF

# sysctl -w vm.max_map_count=262144 && \
sysctl -w net.core.netdev_max_backlog=4096 && \
sysctl -w net.core.rmem_default=262144 && \
sysctl -w net.core.rmem_max=67108864 && \
sysctl -w net.ipv4.udp_rmem_min=131072 && \
sysctl -w net.ipv4.udp_mem='2097152 4194304 8388608'

Reinicie para que os novos módulos sejam carregado.

# reboot

:: Elastic Stack ::

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/8.x/apt stable main" |  tee -a /etc/apt/sources.list.d/elastic.list
# apt update

:: Elasticsearch ::

Elasticsearch é um mecanismo de pesquisa baseado em texto completo.

# apt install elasticsearch

Se uma JVM for iniciada com tamanhos de heap inicial e máximo desiguais, ela poderá pausar conforme o heap da JVM for redimensionado durante o uso do sistema. Por esse motivo, é melhor iniciar a JVM com os tamanhos de heap inicial e máximo configurados com valores iguais.

Adicione o arquivo e defina e heap.optionsa cerca de um terço da memória do sistema, mas não exceda . Para este exemplo, usaremos 12 GB dos 32 GB de memória disponíveis para heap da JVM.

# echo -e "-Xms12g\n-Xmx12g" > /etc/elasticsearch/jvm.options.d/heap.options

Os limites do sistema aumentados devem ser especificados em um systemd.

# mkdir /etc/systemd/system/elasticsearch.service.d
# cat </etc/systemd/system/elasticsearch.service.d/elasticsearch.conf
[Service]
LimitNOFILE=131072
LimitNPROC=8192
LimitMEMLOCK=infinity
LimitFSIZE=infinity
LimitAS=infinity
EOF

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

# sed -i 's/#cluster.name: my-application/cluster.name: elastiflow/' /etc/elasticsearch/elasticsearch.yml
# sed -i 's/#network.host: 192.168.0.1/network.host: 127.0.0.1/' /etc/elasticsearch/elasticsearch.yml
# sed -i 's/xpack.security.enabled: true/xpack.security.enabled: false/' /etc/elasticsearch/elasticsearch.yml
# echo "indices.query.bool.max_clause_count: 8192" >> /etc/elasticsearch/elasticsearch.yml
# echo "search.max_buckets: 250000" >> /etc/elasticsearch/elasticsearch.yml

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

● elasticsearch.service - Elasticsearch
     Loaded: loaded (/lib/systemd/system/elasticsearch.service; enabled; vendor preset: enabled)
    Drop-In: /etc/systemd/system/elasticsearch.service.d
             └─elasticsearch.conf
     Active: active (running) since Fri 2022-02-04 11:34:39 -03; 53s ago
       Docs: https://www.elastic.co
   Main PID: 4701 (java)
      Tasks: 60 (limit: 38490)
     Memory: 12.7G
        CPU: 52.548s
     CGroup: /system.slice/elasticsearch.service
             ├─4701 /usr/share/elasticsearch/jdk/bin/java -Xshare:auto -Des.networkaddress.cache.ttl=60 .....
             └─4893 /usr/share/elasticsearch/modules/x-pack-ml/platform/linux-x86_64/bin/controller

fev 04 11:34:23 debian systemd[1]: Starting Elasticsearch...
fev 04 11:34:39 debian systemd[1]: Started Elasticsearch.

Cheque se o mesmo esta funcionando

# curl -X GET "http://127.0.0.1:9200"

Retorno algo como….

{
  "name" : "debianFlows",
  "cluster_name" : "elastiflow",
  "cluster_uuid" : "mgKF5EP-SnKbbULl3D6aXQ",
  "version" : {
    "number" : "8.4.2",
    "build_flavor" : "default",
    "build_type" : "deb",
    "build_hash" : "89f8c6d8429db93b816403ee75e5c270b43a940a",
    "build_date" : "2022-09-14T16:26:04.382547801Z",
    "build_snapshot" : false,
    "lucene_version" : "9.3.0",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
}

:: 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.

# echo "telemetry.enabled: false" >> /etc/kibana/kibana.yml
# echo "telemetry.optIn: false" >> /etc/kibana/kibana.yml
# echo "newsfeed.enabled: false" >> /etc/kibana/kibana.yml
# echo "server.host: \"0.0.0.0\"" >> /etc/kibana/kibana.yml
# echo "server.maxPayload: 8388608" >> /etc/kibana/kibana.yml
# echo "elasticsearch.requestTimeout: 132000" >> /etc/kibana/kibana.yml
# echo "elasticsearch.shardTimeout: 120000" >> /etc/kibana/kibana.yml

# vim /etc/kibana/kibana.yml

Ajuste para o endereço da sua URL(Domínio ou IP) pública, exemplo:

server.publicBaseUrl: "http://192.168.0.30:5601"

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

● kibana.service - Kibana
     Loaded: loaded (/etc/systemd/system/kibana.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2022-02-03 17:45:24 -03; 3s ago
       Docs: https://www.elastic.co
   Main PID: 4638 (node)
      Tasks: 11 (limit: 6548)
     Memory: 138.6M
        CPU: 4.339s
     CGroup: /system.slice/kibana.service
             └─4638 /usr/share/kibana/bin/../node/bin/node /usr/share/kibana/bin/../src/cli/dist\ 
                                           --logging.dest=/var/log/kibana/kibana.log\ 
                                           --pid.file=/run/kibana/kibana.pi>

fev 03 17:45:24 deb11 systemd[1]: Started Kibana.

:: ElastiFlow ::

ElastiFlow fornece coleta e visualização de dados de fluxo de rede usando o Elastic Stack.

# apt install libpcap-dev
# wget https://elastiflow-packages.s3.amazonaws.com/flow-collector/flow-collector_5.6.0_linux_amd64.deb
# dpkg -i flow-collector_5.6.0_linux_amd64.deb
# apt install -f
# systemctl daemon-reload 
# systemctl enable flowcoll
# systemctl start flowcoll
# systemctl status flowcoll

● flowcoll.service - ElastiFlow Unified Flow Collector
     Loaded: loaded (/etc/systemd/system/flowcoll.service; enabled; vendor preset: enabled)
    Drop-In: /etc/systemd/system/flowcoll.service.d
             └─flowcoll.conf
     Active: active (running) since Fri 2022-02-04 13:49:34 -03; 8s ago
       Docs: https://docs.elastiflow.com
   Main PID: 10763 (flowcoll)
      Tasks: 9 (limit: 38490)
     Memory: 33.0M
        CPU: 105ms
     CGroup: /system.slice/flowcoll.service
             └─10763 /usr/share/elastiflow/bin/flowcoll

# wget https://raw.githubusercontent.com/elastiflow/elastiflow_for_elasticsearch/master/kibana/kibana-7.14.x-codex-dark.ndjson
# curl -XPOST "http://127.0.0.1:5601/api/saved_objects/_import?overwrite=true"\
 -k -H "kbn-xsrf: true" -H "securitytenant: global" --form file=@kibana-7.14.x-codex-dark.ndjson

No retornos dos comando curl certifique-se de ter no inicio a mensagem “success”:true”

{"successCount":229,"success":true,"warnings":[],"successResults...............

Configurações Avançadas Recomendadas do Kibana

Acesse seu Kibana no navegador. http://____:5601

Realizando esses ajustes avançados o Kibana produzirá uma experiência mais amigável ao usar o ElastiFlow. Essas configurações são feitas no Kibana, em Stack Management -> Advanced Settings.
Use a busca para localizar e ajustar os seguintes valores:

Pin filters by default: On
Highlight results : Off
Store URLs in session storage: On
Dark mode: On
Day of week: Monday
Formatting locale: Portuguese (Brazil)
Number format: 0,0.[00]
Percent format: 0,0.[00]%
Time filter defaults:

{
  "from": "now-1h/m",
  "to": "now"
}

Time filter quick ranges:

[
  {
    "from": "now-15m/m",
    "to": "now/m",
    "display": "Last 15 minutes"
  },
  {
    "from": "now-30m/m",
    "to": "now/m",
    "display": "Last 30 minutes"
  },
  {
    "from": "now-1h/m",
    "to": "now/m",
    "display": "Last 1 hour"
  },
  {
    "from": "now-2h/m",
    "to": "now/m",
    "display": "Last 2 hours"
  },
  {
    "from": "now-4h/m",
    "to": "now/m",
    "display": "Last 4 hours"
  },
  {
    "from": "now-12h/m",
    "to": "now/m",
    "display": "Last 12 hours"
  },
  {
    "from": "now-24h/m",
    "to": "now/m",
    "display": "Last 24 hours"
  },
  {
    "from": "now-48h/m",
    "to": "now/m",
    "display": "Last 48 hours"
  },
  {
    "from": "now-7d/m",
    "to": "now/m",
    "display": "Last 7 days"
  },
  {
    "from": "now-30d/m",
    "to": "now/m",
    "display": "Last 30 days"
  },
  {
    "from": "now-60d/m",
    "to": "now/m",
    "display": "Last 60 days"
  },
  {
    "from": "now-90d/m",
    "to": "now/m",
    "display": "Last 90 days"
  }
]

Ajustes finos:

# vim /etc/systemd/system/flowcoll.service.d/flowcoll.conf

Ajustes ELASTICSEARCH

Environment="EF_FLOW_OUTPUT_ELASTICSEARCH_ENABLE=true"
Environment="EF_FLOW_OUTPUT_ELASTICSEARCH_TIMESTAMP_SOURCE=end"
Environment="EF_FLOW_OUTPUT_ELASTICSEARCH_INDEX_TEMPLATE_ILM_LIFECYCLE=elastiflow"
#Environment="EF_FLOW_OUTPUT_ELASTICSEARCH_USERNAME=elastic"
#Environment="EF_FLOW_OUTPUT_ELASTICSEARCH_PASSWORD=changeme"

Ajustes DNS

Environment="EF_FLOW_DECODER_ENRICH_DNS_ENABLE=true"
Environment="EF_FLOW_DECODER_ENRICH_DNS_NAMESERVER_IP=1.1.1.1"

Ajustes MAXMIND

Environment="EF_FLOW_DECODER_ENRICH_MAXMIND_ASN_ENABLE=true" 
Environment="EF_FLOW_DECODER_ENRICH_MAXMIND_GEOIP_ENABLE=true"
Environment="EF_FLOW_DECODER_ENRICH_MAXMIND_GEOIP_LANG=pt-BR"
Environment="EF_FLOW_DECODER_ENRICH_MAXMIND_ASN_PATH=maxmind/GeoLite2-ASN.mmdb"
Environment="EF_FLOW_DECODER_ENRICH_MAXMIND_GEOIP_PATH=maxmind/GeoLite2-City.mmdb"

Base MAXMIND.

# cd /etc/elastiflow/maxmind
# wget https://git.io/GeoLite2-ASN.mmdb
# wget https://git.io/GeoLite2-City.mmdb
# wget https://git.io/GeoLite2-Country.mmdb

Reiniciando os serviços

# systemctl daemon-reload
# systemctl restart flowcoll
# systemctl status flowcoll
# systemctl restart elasticsearch kibana
# systemctl status elasticsearch kibana

Configure seu router para enviar os flows

Bonus: Huawei NE Netstream (NetFlow)

ip netstream as-mode 32
ip netstream timeout active 1
ip netstream timeout inactive 15
ip netstream export version 9 origin-as
ip netstream export index-switch 32
ip netstream export template timeout-rate 2
ip netstream sampler fix-packets 128 inbound
ip netstream sampler fix-packets 128 outbound
ip netstream export source IPv4_LOOPBACK_ORIGEM
ip netstream export host IPv4_SERVIDOR 9995
ip netstream export template option sampler
ip netstream export template option application-label
#
ipv6 netstream as-mode 32
ipv6 netstream timeout active 1
ipv6 netstream timeout inactive 15
ipv6 netstream export version 9 origin-as
ipv6 netstream export index-switch 32
ipv6 netstream export template timeout-rate 2
ipv6 netstream sampler fix-packets 128 inbound
ipv6 netstream sampler fix-packets 128 outbound
ipv6 netstream export source IPv4_LOOPBACK_ORIGEM
ipv6 netstream export host IPv4_SERVIDOR 9995
ipv6 netstream export template option sampler
 
# CONFIG NO SLOT -- slot 9 ou 10 NE8000 / slot 3 NE40
# EXECUTE O CMD NO ROOT, COMANDO NÃO FUNCIONA NO VIRTUAL SYSTEM
slot 9
 ip netstream sampler to slot self
 ipv6 netstream sampler to slot self
 
# APLICAR APENAS NAS INTERFACES UPSTREAM (LINK IP, PTT, IX...)
ip netstream inbound
ip netstream outbound
ipv6 netstream inbound
ipv6 netstream outbound
 
# EM CASO DE INTERFACES DE CDN INTERNO, APLICAR:
ip netstream inbound
ipv6 netstream inbound
 
# EM CASO DE INTERFACE BILATERAL (ONDE TANTO RECEBE QUANTO ENVIA CONTEÚDO), APLICAR:
ip netstream inbound
ipv6 netstream inbound

Bonus: Mikrotik

/ip traffic-flow
set active-flow-timeout=1m cache-entries=4k enabled=yes interfaces=INTERFACES_COLETAR
/ip traffic-flow target 
add dst-address=IP_SERVER_ASSTATS port=9995 src-address=IP_ORIGEM version=9

Verificar se os pacotes estão chegando na porta 9995

# apt install tcpdump
# tcpdump -i ens18 -n udp port 9995 -T cnfp

Acesse eu Kibana e seja feliz!

Escolha sua Dash

Gostou e quer me ajudar a 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.

Abraço!

Fonte:
https://docs.elastiflow.com

O post Aprenda instalar o ElastiFlow, uma poderosa ferramenta para análise de tráfego de rede no Debian 11 Bullseye apareceu primeiro em Remontti.

Como se proteger de ataques DDoS com FastNetMon de graça – Integração FRR vs NE-Huawei – Bonus Gráficos Grafana

Rudimar Remontti — Wed, 16 Feb 2022 20:00:18 +0000

Existe um tutorial mais atualizado acesse:

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 (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 11 (Instalação Limpa). O hardware utilizado por ser bem generoso, 1CPU e 1GB de memoria.

Nesse gráfico podemos ver um servidor analisando 10GB via Netflow e quase nada sendo usado de recursos. Mais ao final irei configurar o Graphith para termos gráficos qual irá abusar mais do hardware, porém para muitos gráficos não são necessários, e sim algo que o proteja.

Cenário fictício de exemplo:
Seu AS: 260072 (Madruga Telecom)
Operadora AS: 71 (BrUxa71 Telecom)
10.100.0.1/30 – Huawei NE
10.100.0.2/30 – 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.100.0.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.

# vim /etc/network/interfaces

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

iface enp0s3 inet static
    address 10.100.0.2/30
    post-up /usr/sbin/ip route add default via 10.100.0.1 src 72.72.72.255

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.

 system-view
Enter system view, return user view with return command.
[~NE-SEUMADRUGA] ip route-static 72.72.72.255 255.255.255.255 10.100.0.2 description FASTNETMON
[*NE-SEUMADRUGA] 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

table inet filter {

        chain input {
                type filter hook input priority 0;

                # Permite que apenas conexoes que foram aberta pelo servidor seja respondidas
                ip daddr 72.72.72.255 ct state related,established counter accept
                ip daddr 72.72.72.255 counter drop

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

Inicie o 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)

Para ver o comparativo da versão gratuita acesse aqui. Já antemão o que não teremos suporte é ao IPv6 e alguns recursos extras.
Conversando com Pavel Odintsov entendeu que no Brasil os planos da versão paga ficam muito pesada para a grande maioria devido a alto do dólar, então ele criou um cupom com 50% de desconto para os brasileiros.
Segue os lins com o desconto:
Licença 10Gb
Licença 40GB
Licença 100GB

Vamos a instalação [Doc Oficial]

# apt install wget tcpdump net-tools zip curl
# cd /tmp/
# wget https://install.fastnetmon.com/installer -Oinstaller
# chmod +x installer
# ./installer -install_community_edition

É necessário que vc informe seu e-mail durante a instalação. (Para usar a Comunidade FastNetMon você deve fornecer seu e-mail corporativo válido e aceitar receber informações sobre nossa edição comercial e atualizações de segurança)

18:13:33 Will log all installation process details into file: /tmp/fastnetmon_install_1170.log
18:13:33 Installer build git version is: b21331ee349eaf0bc2abc71a466802cd26ee2347 build time is: 2022-01-17T16:17:51
18:13:33 Install FastNetMon Community edition

We offer significantly improved FastNetMon Advanced edition: 
FastNetMon Advanced
You could order free one-month trial for Advanced edition here: 
Order trial

To use FastNetMon Community you must provide your valid corporate email and accept 
to receive information about our commercial edition and security updates.
You can find our privacy policy here https://fastnetmon.com/privacy-policy/

Provide your corporate email here, personal emails are not allowed: seu@email.com.br
18:13:41 Apply sysctl configuration changes
18:13:41 Disable rp_filter for all interfaces
18:13:41 Installing on Debian 11.2 platform
18:13:41 Download binary package
18:15:27 Successfully installed FastNetMon Community edition

Adicione todos os prefixos do seu AS, são esses os IPs serão feito analise.

# vim /etc/networks_list

Exemplo:

72.72.72.0/22

Ajustando as configurações do /etc/fastnetmon.conf.
Habilitamos o serviço de netflow: `netflow = off` para `netflow = on`

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

Ajustes de tempo

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

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

Ative medidores de velocidade por sub-rede, para listar a velocidade da faixa em bps e pps para ambas as direções. (Parece que removeram na última versão)

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

Altera o top 7 para o top 10 ao usar o comando fastnetmon_client

# 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).

ban_for_pps = on
ban_for_bandwidth = on
ban_for_flows = off

ban_for_tcp_bandwidth = off
ban_for_udp_bandwidth = off
ban_for_icmp_bandwidth = off

ban_for_tcp_pps = off
ban_for_udp_pps = off
ban_for_icmp_pps = off

Vamos ativar todos os filtros:

# 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

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 90.000 pps.

# sed -i 's/threshold_pps = 20000/threshold_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.

threshold_mbps = 1050
threshold_flows = 3500

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

Por o serviço ira ficar ouvindo em todos os endereços IPs do seu servidor (netflow_host = 0.0.0.0), logo o mais correto seria deixa-lo apenas para o IP privado.

# sed -i 's/netflow_host = 0.0.0.0/netflow_host = 10.100.0.2/' /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.

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 10.100.0.2:52055           0.0.0.0:*                           1599/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.

Acesse seu roteador Huawei:

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

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

[*NE-SEUMADRUGA] slot <0-10>
[*NE-SEUMADRUGA] ip netstream sampler to slot self
[*NE-SEUMADRUGA]  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 ens192 -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.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.608068 IP 10.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.668054 IP 10.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.691123 IP 10.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.768055 IP 10.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.781129 IP 10.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.831133 IP 10.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.858054 IP 10.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.941124 IP 10.100.0.1.40000 > 10.100.0.2.52055: NetFlow v9
14:25:19.958060 IP 10.100.0.1.40000 > 10.100.0.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.

# > /etc/networks_whitelist
# 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"

FRR

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

# apt install curl apt-transport-https gnupg2 tree net-tools
# curl -s https://deb.frrouting.org/frr/keys.asc | apt-key add -
# echo deb https://deb.frrouting.org/frr bullseye frr-8 | tee -a /etc/apt/sources.list.d/frr.list
# apt update
# apt install frr frr-doc

Parâmetros kernel

# echo 'net.ipv4.ip_forward = 1' >> /etc/sysctl.conf
# echo "net.ipv4.conf.all.rp_filter = 0" >> /etc/sysctl.conf
# echo "net.ipv4.conf.default.rp_filter = 0" >> /etc/sysctl.conf
# echo "net.ipv4.conf.lo.rp_filter = 0" >> /etc/sysctl.conf
# echo "net.ipv4.conf.`ip -br link |awk '{print $1}' |grep -v lo`.rp_filter = 0" >> /etc/sysctl.conf
# sysctl -p

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`

deb11# show running-config 
Building configuration...

Current configuration:
!
frr version 8.3.1
frr defaults traditional
hostname deb11
log syslog informational
no ip forwarding
no ipv6 forwarding
service integrated-vtysh-config
!
line vty
!
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

configure terminal
!
ip prefix-list FASTNETMON_EXPORT seq 5 permit 72.72.72.0/23 le 32
ip prefix-list FASTNETMON_EXPORT seq 10 permit 72.72.74.0/23 le 32
!
!
route-map MARK_FASTNETMON_IMPORT deny 10
!
route-map MARK_FASTNETMON_EXPORT permit 10
 match ip address prefix-list FASTNETMON_EXPORT
 set community 65001:666
!
router bgp 65001
 bgp router-id 10.100.0.2
 neighbor 10.100.0.1 remote-as 260072
 neighbor 10.100.0.1 description "NE8K_BORDA"
# neighbor 10.100.0.1 ebgp-multihop 255 # (Caso seja multihop)
 !
 address-family ipv4 unicast
  neighbor 10.100.0.1 route-map MARK_FASTNETMON_IMPORT in
  neighbor 10.100.0.1 route-map MARK_FASTNETMON_EXPORT out
 exit-address-family
!
line vty
!
end
write memory
exit

Vamos ao Huawei

 system-view
Enter system view, return user view with return command.

Crie uma rota estática de Blackhole

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

Crie um filtro que irá aceitar qualquer rota /32

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

Crie os prefixos publico para rejeitar e não cair em blackhole mesmo quando atacado, caso você deixar o fastnetmon anúnciar seu NE pode rejeitar (Ex IP Servidores ou CGNAT)

[*NE-SEUMADRUGA] ip ip-prefix  IGNORE_PREFIX_FASTNETMON_IPV4 index 10 permit 72.72.72.224 28 greater-equal 28 less-equal 32
[*NE-SEUMADRUGA] 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 a community 65001:666

[*NE-SEUMADRUGA] ip community-filter basic COMM_FASTNETMON_BLACKHOLE index 10 permit 65001:666

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

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

A 2º é o que vir marcado do fastnetmon com 65001:666 (COMM_FASTNETMON_BLACKHOLE) 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 comum 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!

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

E a 3ª ignoramos o resto como boas praticas.

[*NE-SEUMADRUGA] 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.

[*NE-SEUMADRUGA] route-policy FASTNETMON_EXPORT_IPV4 deny node 9999
[*NE-SEUMADRUGA] commit

Vamos ao peer

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

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

[~NE-SEUMADRUGA] bgp 260072
[*NE-SEUMADRUGA] peer 10.100.0.2 ignore
[*NE-SEUMADRUGA] commit

Para subir novamente:

[~NE-SEUMADRUGA] bgp 260072
[*NE-SEUMADRUGA] undo peer 10.100.0.2 ignore
[*NE-SEUMADRUGA] commit

Verifique se sua sessão subiu:

[*NE-SEUMADRUGA] display bgp peer | include 10.100.0.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.100.0.2                       4       65001   897801  1088107     0 2496h26m Established        0

No FRR use `show bgp summary`

# vtysh

# show bgp summary
IPv4 Unicast Summary:
BGP router identifier 10.100.0.2, local AS number 65001 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.100.0.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á adiciar 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 irei repassar para operadora com a commnunity da operadora. Para isso crie então primeiro a community-filter de Blackhole sua.

[~NE-SEUMADRUGA] ip community-filter basic COMM_BLACKHOLE index 10 permit 65444:666

Agora na route policy da operadora crie algo semelhante ao exemplo, sendo que a community de blackhole que sua operadora passou fosse “71:666”:

[~NE-SEUMADRUGA] route-policy UPSTREAM_OP_BRUXADO71_EXPORT_IPV4 permit node 2070
[~NE-SEUMADRUGA]  if-match community-filter COMM_BLACKHOLE
[~NE-SEUMADRUGA]  apply community 71:666

Pronto agora que ja 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.

#!/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 (Grupos sempre começam com "-" )
ID_CHAT='-1000000000000'

if [ "$2" = "incoming" ]; then
  TIPO="Sendo atacado"
else 
  TIPO="Realizando um ataque"
fi

# Desbanindo um IP
if [ "$4" = "unban" ]; then
  /usr/local/bin/telegram -m "$ID_CHAT" "UNBAN IP: $1" "->> Removido da blackhole"
  # Remove IP do anuncio para o FRR
  vtysh --command "configure terminal
  no ip route $1/32 lo
  router bgp 65001
   address-family ipv4 unicast
    no network $1/32
  "
  # 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
  /usr/local/bin/telegram -m "$ID_CHAT" "BAN IP: $1 $TIPO [$3 pps]" "->> Anunciado em blackhole"
  /usr/local/bin/telegram -f "$ID_CHAT" /var/log/fastnetmon_attacks/$1* $1 "Logs do ataque ao IP $1"
  # Anuncia IP ao FRR
  vtysh --command "configure terminal
  ip route $1/32 lo
  router bgp 65001
   address-family ipv4 unicast
    network $1/32
  "
    exit 0
fi

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

De permissão para execução

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

Restarte o fastnetmon

# systemctl restart fastnetmon

Se quiser fazer um teste manual anunciando um IP (um que não esteja em uso né!!! rsrsrs) exemplo: 72.72.73.255/32
Adicionando:

# vtysh --command "configure terminal
  ip route 72.72.73.255/32 lo
  router bgp 65001
   address-family ipv4 unicast
    network 72.72.73.255/32"

Verificando se esta enviando:

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

BGP table version is 3, local router ID is 10.100.0.2, vrf id 0
Default local pref 100, local AS 65001
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

Removendo:

# vtysh --command "configure terminal
  no ip route 72.72.73.255/32 lo
  router bgp 65001
   address-family ipv4 unicast
    no network 72.72.73.255/32"

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

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 lsb-release gnupg2 curl wget
# 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

Edite o influxdb.conf

# vim /etc/influxdb/influxdb.conf

Localize [[graphite]] e abaixo adicione:

[[graphite]]
  enabled = true
  bind-address = ":2003"
  protocol = "tcp"
  consistency-level = "one"
  separator = "."
  batch-size = 5000 # will flush if this many points get buffered
  batch-timeout = "1s" # will flush at least this often even if we haven't hit buffer limit
  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 graphite foi criado.

# influx

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

> use graphite

Using database graphite

> show measurements

name: measurements
name
----
hosts
networks
total

> exit

Grafana

Adicione o repositório do grafana e instale-o

# wget -q -O - https://packages.grafana.com/gpg.key | apt-key add -
# echo "deb https://packages.grafana.com/oss/deb stable main" | tee -a /etc/apt/sources.list.d/grafana.list
# apt update; apt install grafana

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.

No menu Configuration e vá em Data sources, clique em Add data source

Localize influxDB e selecione

Preencha apenas:
URL: http://localhost:8086
Database: graphite
E clique em Save & test, você deve ter a resposta Data source is working.

Faça download aqui das Dashs e importe.

Não esqueça de definir o banco InfluxDB

Você pode pesquisar por mais dashs em: https://grafana.com/grafana/dashboards/?search=fastnetmon

Fastnetmon

Fastnetmon PAINEL GERAL

Fastnetmon TOP HOSTS (+100MB)

Fastnetmon TOP HOSTS (+300MB)

Fastnetmon TOP NETWORKS

Fastnetmon TOP TRÁFEGO DE SAÍDA

Fastnetmon TRÁFEGO REDE ESPECIFICADA

Fastnetmon TRÁFEGO POR IP ESPECIFICO

E como ficou o hardware agora?

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/

BÔNUS PEGANDO PREFIXO /24 DO IP ATACADO E ANUNCIANDO COM OUTRA COMMUNITY PARA MITIGAR

#####################
# SCRIPT FASTNETMON
#####################

#!/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)

# Pegando prefixo 24
ip32=$1
prefixo24="${ip32%.*}.0/24"

# Defina o ID do Chat ou Grupo (Grupos sempre começam com "-" )
ID_CHAT='-1000000000000'
 
if [ "$2" = "incoming" ]; then
  TIPO="Sendo atacado"
else 
  TIPO="Realizando um ataque"
fi
 
# Desbanindo um IP
if [ "$4" = "unban" ]; then
  /usr/local/bin/telegram -m "$ID_CHAT" "UNBAN IP: $1" "->> Removido da blackhole"
  # Remove IP do anuncio para o FRR
  vtysh --command "configure terminal
  no ip route $1/32 lo
  no ip route $prefixo24 lo
  router bgp 65001
   address-family ipv4 unicast
    no network $1/32
    no network $prefixo24
  "
  # 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
  /usr/local/bin/telegram -m "$ID_CHAT" "BAN IP: $1 $TIPO [$3 pps]" "->> Anunciado em blackhole"
  /usr/local/bin/telegram -f "$ID_CHAT" /var/log/fastnetmon_attacks/$1* $1 "Logs do ataque ao IP $1"
  # Anuncia IP ao FRR
  vtysh --command "configure terminal
  ip route $1/32 lo
  ip route $prefixo24 lo
  router bgp 65001
   address-family ipv4 unicast
    network $1/32
    network $prefixo24
  "
    exit 0
fi
 
if [ "$4" == "attack_details" ]; then
  #/usr/local/bin/telegram -m "$ID_CHAT" "BAN" "FastNetMon: IP $1 blocked because $2 attack with power $3 pps"
  exit 0
fi


#####################
# FRR
#####################


!
frr version 8.5.1
frr defaults traditional
hostname fnm
log syslog informational
no ipv6 forwarding
service integrated-vtysh-config
!
router bgp 65001
 bgp router-id 172.16.1.2
 neighbor 172.16.1.1 remote-as 12345
 neighbor 172.16.1.1 description "BORDA"
 !
 address-family ipv4 unicast
  neighbor 172.16.1.1 route-map MARK_FASTNETMON_IMPORT in
  neighbor 172.16.1.1 route-map MARK_FASTNETMON_EXPORT out
 exit-address-family
exit
!
ip prefix-list FASTNETMON_EXPORT_32 seq 5 permit 200.0.0.0/22 le 32
!
ip prefix-list FASTNETMON_EXPORT_24 seq 5 permit 200.0.0.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
!
end
write memory


#####################
# HUAWEI
#####################


#Configurando filtros e sessão BGP
ip route-static 192.0.2.1 255.255.255.255 NULL0 description BLACKHOLE

# Aceitas os prefixos 32 do AS para blackhole
ip ip-prefix  ACCEP_PREFIX_MASK32_FASTNETMON_IPV4 index 10 permit 200.0.0.0 22 greater-equal 32

# Aceitas os prefixos 24 do AS para mitigar
ip ip-prefix  ACCEP_PREFIX_MASK24_FASTNETMON_IPV4 index 10 permit 200.0.0.0 22 greater-equal 24

#Iginora Prefixos do CGNAT/Servidores
ip ip-prefix  IGNORE_PREFIX_FASTNETMON_IPV4 index 10 permit 200.0.1.0 28 greater-equal 28 less-equal 32
ip ip-prefix  IGNORE_PREFIX_FASTNETMON_IPV4 index 20 permit 200.0.2.0 26 greater-equal 26 less-equal 32

# community que o FRR ira enviar
ip community-filter basic COMM_FASTNETMON_BLACKHOLE_32 index 10 permit 65001:666
ip community-filter basic COMM_FASTNETMON_BLACKHOLE_24 index 10 permit 65001:777

# Define comm para usar nos RP das operadoras
ip community-filter basic COMM_BLACKHOLE_32 index 10 permit 65444:666
ip community-filter basic COMM_BLACKHOLE_24 index 10 permit 65444:777

# RP
route-policy FASTNETMON_IMPORT_IPV4 deny node 1000
 if-match ip-prefix IGNORE_PREFIX_FASTNETMON_IPV4

route-policy FASTNETMON_IMPORT_IPV4 permit node 1010
 if-match community-filter COMM_FASTNETMON_BLACKHOLE_32 
 apply local-preference 999
 apply ip-address next-hop 192.0.2.1
 apply community 65444:666
 if-match ip-prefix ACCEP_PREFIX_MASK32_FASTNETMON_IPV4
 
route-policy FASTNETMON_IMPORT_IPV4 permit node 1020
 if-match community-filter COMM_FASTNETMON_BLACKHOLE_24
 apply local-preference 999
 apply ip-address next-hop 192.0.2.1
 apply community 65444:777
 if-match ip-prefix ACCEP_PREFIX_MASK24_FASTNETMON_IPV4
 
route-policy FASTNETMON_IMPORT_IPV4 deny node 9999
route-policy FASTNETMON_EXPORT_IPV4 deny node 9999

# FILTRO OPERADORA

# Envia para community de blackhole da operadora 
route-policy UPSTREAM_OP_BRUXADO71_EXPORT_IPV4 permit node 2070
 if-match community-filter COMM_BLACKHOLE_32
 apply community 71:666

# Envia para community de blackhole de mitigraçação
route-policy UPSTREAM_OP_BRUXADO71_EXPORT_IPV4 permit node 2070
 if-match community-filter COMM_BLACKHOLE_24
 apply community 71:999

O post Como se proteger de ataques DDoS com FastNetMon de graça – Integração FRR vs NE-Huawei – Bonus Gráficos Grafana apareceu primeiro em Remontti.