Arquivos Mikrotik - Remontti

Configurando OpenVPN no RouterOS v7

Rudimar Remontti — Fri, 12 Apr 2024 20:58:46 +0000

Hoje, vamos aprender a configurar o OpenVPN no RouterOS v7. Com vasta experiência junto a ISPs, percebo que muitos ainda utilizam protocolos como PPTP, SSTP e L2TP, que oferecem menor segurança. Optar pelo OpenVPN é uma escolha superior, pois ele não só fornece criptografia robusta e configurações altamente personalizáveis, mas também garante uma proteção mais eficaz contra as vulnerabilidades comuns nesses protocolos menos seguros.

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$user%20ORIGEM:%20$callerId&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$user%20ORIGEM:%20$callerId&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.

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.

Monitorando no Zabbix as sessões BGP do RouterOS v6 (Mikrotik) via SNMP

Rudimar Remontti — Tue, 28 Dec 2021 20:31:48 +0000

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.

Monitorando no Zabbix as sessões BGP do RouterOS/Mikrotik (Script Python)

Rudimar Remontti — Wed, 17 Nov 2021 00:03:50 +0000

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     
# ./mikrotikBgp.py      
# ./mikrotikBgp.py

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

O post Monitorando no Zabbix as sessões BGP do RouterOS/Mikrotik (Script Python) apareceu primeiro em Remontti.

TR-069 – Instalação do GenieACS no Debian 11 Bullseye

Rudimar Remontti — Fri, 29 Oct 2021 19:56:25 +0000

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

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.

Configurando interface de rede no Debian 10/11/12/13

Rudimar Remontti — Sat, 18 Sep 2021 20:14:42 +0000

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.

Port knocking, aprenda a melhorar as política de segurança de seu firewall Linux e Mikrotik

Rudimar Remontti — Sat, 13 Mar 2021 21:23:34 +0000

Port knocking é um método de abrir portas externamente em um firewall, realizando tentativas de conexões em uma sequemcia de portas fechadas pré-especificadas, e depois que esta sequência estiver correta as regras de firewall são modificadas temporariamente para permitir que o host que “bateu” nas portas tenha acesso.

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       wait  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

$ 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


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

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.

Monitoramento com o Observium no Debian 10

Rudimar Remontti — Tue, 20 Oct 2020 20:03:05 +0000

Observium é uma ferramenta de gerenciamento e monitoramento de rede gratuita e de código aberto que pode ser usada para monitorar todos os dispositivos de rede. Ele é escrito em PHP e usa SNMP para coletar os dados do dispositivo conectado e monitorá-los usando uma interface da web.

Observium oferece suporte a vários hardwares de rede e sistemas operacionais, incluindo Linux, Windows, FreeBSD, Cisco, Dell, Netscaler, Huawei, Mikrotik e muito mais. O Observium oferece uma interface poderosa, simples e fácil de usar para monitorar a saúde e o status de sua rede.

Profissionalmente desenvolvido e mantido por uma equipe de experientes engenheiros de rede e administradores de sistemas, o Observium é uma plataforma projetada e construída por seus usuários.

A Comunidade Observium está disponível gratuitamente para todos e recebe atualizações e recursos duas vezes por ano. O Observium Professional adiciona acesso prioritário a atualizações diárias e novos recursos por uma pequena taxa anual.

Requisitos:

* Debian 10 (Buster) -> Instalação Limpa
* Passo-a-passo como criar um servidor WEB Apache + PHP + MariaDB + phpMyAdmin no Debian 10 Buster “LAMP”
A instalação do phpMyAdmin não é necessária.

Instale os pacotes necessários:

# apt install snmp fping python-mysqldb rrdtool subversion whois mtr-tiny ipmitool graphviz imagemagick wget

Crie o banco de dados do observium

# mariadb -u root -p

Não esqueça de alterar SUA_SENHA

CREATE DATABASE observium DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
GRANT ALL PRIVILEGES ON observium.* TO 'observium'@'localhost' IDENTIFIED BY 'SUA_SENHA';
FLUSH PRIVILEGES;
QUIT;

Edições Observium

Como dito o Observium vem em duas edições, uma Open Source Community Edition lançada em um ciclo semestral e uma edição com recursos adicionais, correções rápidas de bugs e melhorias de recursos diariamente. Caso queira a versão “Pro” acesse https://www.observium.org/

Como a a gente é pobre (zueira) vamos instalar a versão Community Edition
Se desejar instalar o Community Edition, instale usando a versão .tar.gz mais recente.

Baixe o .tar.gz mais recente do Observium e descompacte:

# cd /var/www/
# wget http://www.observium.org/observium-community-latest.tar.gz
# tar zxvf observium-community-latest.tar.gz

Crie o diretório para armazenar RRDs e ous logs:

# mkdir /var/www/observium/rrd 
# mkdir /var/www/observium/logs

Ajustes as permissões:

# chown www-data. /var/www/observium/ -R

Crie uma cópia do config.php.default para config.php e ajustes os valores do banco de dados colocando os valores criado no passo anterior:

# cp /var/www/observium/config.php.default /var/www/observium/config.php
# vim /var/www/observium/config.php

$config['db_extension'] = 'mysqli';
$config['db_host']      = 'localhost';
$config['db_user']      = 'observium';
$config['db_pass']      = 'SUA_SENHA';
$config['db_name']      = 'observium';

Configure o banco de dados:

# php /var/www/observium/discovery.php -u

Retornará:

  ___   _                              _
 / _ \ | |__   ___   ___  _ __ __   __(_) _   _  _ __ ___
| | | || '_ \ / __| / _ \| '__|\ \ / /| || | | || '_ ` _ \
| |_| || |_) |\__ \|  __/| |    \ V / | || |_| || | | | | |
 \___/ |_.__/ |___/ \___||_|     \_/  |_| \__,_||_| |_| |_|
                     Observium Community Edition 20.9.10731
                                  https://www.observium.org

Install initial database schema ... done.
-- Updating database/file schema
416 -> 417 # (db) .. Done (0s).
417 -> 418 # (db) . Done (0s).
418 -> 419 # (db) .... Done (1s).
419 -> 420 # (db) .. Done (0s).
420 -> 421 # (db) ... Done (0s).
421 -> 422 # (db) .. Done (0s).
422 -> 423 # (db) ...... Done (0s).
423 -> 424 # (php)  Done (0s).
424 -> 425 # (db) . Done (0s).
425 -> 426 # (db) ............... Done (0s).
426 -> 427 # (db) ... Done (0s).
427 -> 428 # (db) ... Done (0s).
428 -> 429 # (db) ... Done (0s).
429 -> 430 # (db) (WARNING! Required MySQL version 5.6+ or MariaDB 10.0+).... Done (0s).
430 -> 431 # (db) ..... Done (0s).
431 -> 432 # (php)  Done (0s).
432 -> 433 # (db) ......... Done (0s).
433 -> 434 # (db) ... Done (0s).
434 -> 435 # (db) . Done (0s).
-- Done.

Como o php-mcrypt não está mais no repositório do Debian 10 (php.7.3) vamos instala-lo na mão:

# apt install php-dev libmcrypt-dev mcrypt
# pecl channel-update pecl.php.net
# pecl install channel://pecl.php.net/mcrypt-1.0.2

Edite o php.ini

# vim /etc/php/7.3/cli/php.ini

Inclua:

extension=mcrypt.so

Verifique se a extensão esta sendo carregada, deve retornar o valor mcrypt.

# php -m | grep mcrypt

Faremos a configuração do apache para que quando o servidor for acessado no navegado o mesmo já abra o Observium, caso você esteja instalando com outros serviços web, ou gosta das coisas organizadas pode pular para o próximo exemplo.

# vim /etc/apache2/sites-available/000-default.conf

Ajuste para:


    ServerAdmin noc@remontti.com.br

    DocumentRoot /var/www/observium/html

    
      SetHandler application/x-httpd-php
    

    
            Options FollowSymLinks
            AllowOverride None
    

    
            DirectoryIndex index.php
            Options FollowSymLinks MultiViews
            AllowOverride All
            Require all granted
    

    ErrorLog  ${APACHE_LOG_DIR}/error_observium.log    
    CustomLog  ${APACHE_LOG_DIR}/access_observium.log combined
    ServerSignature On

Caso você queira proteger para algumas classes de IPs e usar um subdomíno pode usar este modelo. (Mas você pode filtrar por IP também no modelo anterior ajustando os “Require”)

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


   ServerName observium.remontti.com.br
   ServerAdmin noc@remontti.com.br

   # Sem permissões será redirecionada para
   ErrorDocument 403 http://www.remontti.com.br
 
   DocumentRoot /var/www/observium/html

    
      SetHandler application/x-httpd-php
    

    
      Options FollowSymLinks
      AllowOverride None
    
 
   
      DirectoryIndex index.php
      Options FollowSymLinks MultiViews
      AllowOverride All
      Require all denied
      
         
            Require ip 127.0.0.1 ::1 45.80.51.0/29 2804:f123:bebe:c0ca::/64
         
      
   
 
   ErrorLog ${APACHE_LOG_DIR}/error_observium.log
   CustomLog ${APACHE_LOG_DIR}/access_observium.log combined

Habilite a configuração criada acima:

# a2ensite observium

Habilite o o modulo rewrite

# a2enmod rewrite

Reinicie o serviço do apache

# systemctl restart apache2

Vamos utilizar as MIBs do Observium, para isso vamos chama-las (Você pode adicionar outras, verifique quais disponiveis em /var/www/observium/mibs).

# vim /etc/snmp/snmp.conf

Ajuste:

mibs : /var/www/observium/mibs/rfc:/var/www/observium/mibs/net-snmp:/var/www/observium/mibs/mikrotik:/var/www/observium/mibs/huawei

Precisamos ajustar

Observium opera em uma frequência de poller fixa de 5 minutos ou 300 segundos. O processo poller-wrapper deve ser executado nesta frequência NÃO funcionará de outra forma. então vamos criar o /etc/cron.d/observium

# vim /etc/cron.d/observium

Adicione:

# Execute uma descoberta completa de todos os dispositivos uma vez a cada 6 horas
# Run a complete discovery of all devices once every 6 hours
33  */6   * * *   root    /var/www/observium/discovery.php -h all >> /dev/null 2>&1

# Execute a descoberta automática de dispositivos recém-adicionados a cada 5 minutos
# Run automated discovery of newly added devices every 5 minutes
*/5 *     * * *   root    /var/www/observium/discovery.php -h new >> /dev/null 2>&1

# Execute o multithreaded poller wrapper a cada 5 minutos
# Run multithreaded poller wrapper every 5 minutes
*/5 *     * * *   root    /var/www/observium/poller-wrapper.py >> /dev/null 2>&1

# Execute o script de manutenção diariamente para syslog, log de eventos e log de alerta
# Run housekeeping script daily for syslog, eventlog and alert log
13 5      * * *   root    /var/www/observium/housekeeping.php -ysel >> /dev/null 2>&1

# Execute o script de manutenção diariamente para rrds, portas, entradas órfãs no banco de dados e dados de desempenho
# Run housekeeping script daily for rrds, ports, orphaned entries in the database and performance data
47 4      * * *   root    /var/www/observium/housekeeping.php -yrptb >> /dev/null 2>&1

Reinicie o Cron:

# systemctl restart cron

Adicione o primeiro usuário, use o level 10 para o administrador:

# php /var/www/observium/adduser.php

Ex.:

# php /var/www/observium/adduser.php admin suasenha 10

Adicione um primeiro dispositivo para monitorar: (Não esqueça de configurar o SNMP)

# php /var/www/observium/add_device.php   v2c
# php /var/www/observium/add_device.php 10.0.0.100 publicsnmp v2c

Agora acesse seu servidor em seu navegador e entre com usuário e senha criado.

Parabéns!

Espero que tenha lhe instigado/inspirado a buscar mais aprender um pouquinho +

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.

Fonte:
https://docs.observium.org/install_debian/
https://docs.observium.org/web_config/
https://docs.observium.org/dashboard/

O post Monitoramento com o Observium no Debian 10 apareceu primeiro em Remontti.

Instalação do FRRouting (FRR) – Roteamento dinâmico no seu linux +Bônus iBGP

Rudimar Remontti — Sun, 20 Sep 2020 18:20:40 +0000

FRRouting (FRR) é um conjunto de protocolos de roteamento IP para plataformas Linux e Unix que inclui daemons de protocolo para BGP, IS-IS, LDP, OSPF, PIM e RIP.

A integração perfeita do FRR com as pilhas de rede IP Linux/Unix nativas o torna aplicável a uma ampla variedade de casos de uso.

FRR tem suas raízes no projeto Quagga (Fork do Quagga). Na verdade, ele foi iniciado por muitos desenvolvedores de Quagga de longa data que combinaram seus esforços para melhorar a base bem estabelecida do Quagga para criar a melhor pilha de protocolo de roteamento disponível.

Uma ótima apresentação foi feita pelo Junior Corazza. no GTER 46.
BSDRP – Uma opção de softrouter com FRR

Apresentação: ftp://ftp.registro.br/pub/gter/gter46/11-BSDRP.pdf

Requesitos:
Debian 10 Stretch – Instalação Limpa
Debian 11 Bullseye – Instalação Limpa

Antes de começar não esqueça de virar root da forma correta e atualizar os pacotes, e instalar alguns pacotes que serão necessários.

# su -
# apt update
# apt upgrade
# apt install curl apt-transport-https gnupg2 lsb-release tree net-tools

Instalação do Free Range Routing

Pacotes presente do FRR no repositório do Debian 10 estão na versão 6.x.x, e Debian 11 na 7.5.x vou ir além e usar o repositório mais atualizado do FRR disponíveis em https://deb.frrouting.org, mas fica a seu critério se desejar usar o repositório “default”.

Para usar pacotes do repositório FFR faça:

# curl -s https://deb.frrouting.org/frr/keys.asc | apt-key add -

Iremos usar a versão estável oficial mais recente “frr-stable” na variável “FRRVER”, mas é possíveis para também: frr-6 frr-7 frr-8 frr-stable.

# FRRVER="frr-stable"
# echo deb https://deb.frrouting.org/frr $(lsb_release -s -c) $FRRVER | tee -a /etc/apt/sources.list.d/frr.list
# apt update

Podemos entrar agora em nosso respositório varios pacores FRR:

# apt search frr

frr – FRRouting suite
frr-doc – Manual
frr-rpki-rtrlib – Suporte BGP RPKI
frr-rpki-rtrlib-dbgsym – Debug do pacote frr-rpki-rtrlib
frr-snmp – Suporte SNMP
frr-snmp-dbgsym – Debug do pacote frr-snmp
frr-pythontools – Python tools

Instalarei alguns mas fique a seu critério/necessidade.

# apt install frr frr-doc frr-pythontools frr-rpki-rtrlib frr-snmp

Após instalação o diretorio /etc/ffr/ será criado juntamente com seus arquivos de configuração. Arquitetura do diretório:

# tree /etc/frr/

/etc/frr/
├── daemons
├── frr.conf
├── support_bundle_commands.conf
└── vtysh.conf

Como de costume vamos fazer um backup dos arquivos originais caso cometermos alguma “cagada”

# mkdir /etc/frr/backups
# cp /etc/frr/daemons /etc/frr/backups/
# cp /etc/frr/frr.conf /etc/frr/backups/
# cp /etc/frr/vtysh.conf /etc/frr/backups/
# cp /etc/frr/support_bundle_commands.conf /etc/frr/backups/

Antes de mais nada vamos entender um pouco como a aplicação funciona.

No FRR o roteamento é diferente de um roteamento tradicional, ele tem um conjunto de daemons que trabalham juntos para construir a tabela de roteamento.

Cada protocolo principal é implementado em seu próprio daemon, e esses daemons se comunicam com um daemon intermediário (zebra), que é responsável por coordenar as decisões de roteamento.

Esta arquitetura permite alta resiliência, uma vez que um erro, travamento ou exploração em um daemon de protocolo geralmente não afetará os outros. Também é flexível e extensível, uma vez que a modularidade torna mais fácil implementar novos protocolos e vinculá-los ao conjunto. Além disso, cada daemon implementa um sistema de plug-in permitindo que novas funcionalidades sejam carregadas em tempo de execução.

Ilustração da arquitetura em grande escala:

+----+  +----+  +-----+  +----+  +----+  +----+  +-----+
|bgpd|  |ripd|  |ospfd|  |ldpd|  |pbrd|  |pimd|  |.....|
+----+  +----+  +-----+  +----+  +----+  +----+  +-----+
     |       |        |       |       |       |        |
+----v-------v--------v-------v-------v-------v--------v
|                                                      |
|                         Zebra                        |
|                                                      |
+------------------------------------------------------+
       |                    |                   |
       |                    |                   |
+------v------+   +---------v--------+   +------v------+
|             |   |                  |   |             |
| *NIX Kernel |   | Remote dataplane |   | ........... |
|             |   |                  |   |             |
+-------------+   +------------------+   +-------------+

Todos os daemons FRR podem ser gerenciados por meio de um único shell de interface de usuário integrado chamado vtysh. O vtysh se conecta a cada daemon através de um soquete de domínio UNIX e então funciona como um proxy para a entrada do usuário. Além de um front-end unificado, o vtysh também oferece a capacidade de configurar todos os daemons usando um único arquivo de configuração por meio do modo de configuração integrado. Isso evita a sobrecarga de manter um arquivo de configuração separado para cada daemon.

Você encontra mais informações em: http://docs.frrouting.org/en/latest/overview.html

Módulos do kernel

Na documentação oficial de instalação é recomendado fazer alguns ajustes nas configurações de sysctl do Linux, caso para sua realidade não seja necessário pule esta parte.

Os itens a seguir são definidos para habilitar o encaminhamento de IP no kernel:

Encaminhamento IPv4 e IPv6

# vim /etc/sysctl.conf

Descomente:

net.ipv4.ip_forward=1
net.ipv6.conf.all.forwarding=1

Encaminhamento MPLS (Ative se achar necessário)
O suporte MPLS básico foi introduzido no kernel na versão 4.1 e recursos adicionais foram introduzidos na 4.3 e 4.5.

# vim /etc/modules-load.d/modules.conf

Adicione

# Load MPLS Kernel Modules
mpls_router
mpls_iptunnel

Veja quais o(s) nome(s) de sua(s) interface(s) e adicione:

# ip -br link |grep -v lo |awk '{print $1}'
# vim /etc/sysctl.conf

Adicione ao final do arquivo (Anteção para o nome das interfaces: net.mpls.conf.[INTERFACE].input)

# Habilite o processamento de rótulo MPLS em todas as interfaces
net.mpls.conf.enp0s3.input=1
net.mpls.platform_labels=100000

Encaminhamento VRF (Ative se achar necessário)
O seguinte impacta como os soquetes BGP TCP são gerenciados em VRFs:

net.ipv4.tcp_l3mdev_accept=0

Com essa configuração, um soquete BGP TCP é aberto por VRF. Essa configuração garante que outros serviços TCP, como SSH, fornecidos para fins não VRF, sejam bloqueados nas interfaces Linux associadas a VRF.

net.ipv4.tcp_l3mdev_accept=1

Reinicie seu servidor para carregar as novas configurações de kernel.

# reboot

Acesse novamente seu servidor, não esqueça de virar root com o comando “su -”

Após instalado o FRR não fará nada. Isso ocorre porque os daemons devem ser ativados e até o momento não temos nenhum, para ativar edite o arquivo /etc/frr/daemons e determine quais daemons serão ativados colocando um yes no daemon desejado. No meu exemplo vou ativar o bgpd qual deixarei uma “brincadeira” de exemplo ao final.

# vim /etc/frr/daemons

# Para habilitar um daemon específico, simplesmente altere o 'no' correspondente para 'yes', e será necessário reiniciar o serviço.
bgpd=yes 	# BGP
ospfd=no 	# OSPFD (OSPFv2 - IPv4)
ospf6d=no 	# OSPF6D (OSPFv3 - IPv6)
ripd=no 	# RIPD (RIPv2 - IPv4)
ripngd=no 	# RIPNGD (RIPv3 - IPv6)
isisd=no 	# ISISD (IS-IS - Protocolo igp Cisco)
pimd=no 	# PIMD (PIM - Roteamento Multicast)
ldpd=no 	# LDPD (LDP - Labels MPLS para rotas igp)
nhrpd=no 	# NHRPD (NHRP - roteamento entre tuneis)
eigrpd=no 	# EIGRPD (EIGRP - protocolo igp Cisco)
babeld=no 	# BABELD (BABEL - protocolo igp dual-stack)
sharpd=no 	# SHARPD (SHARP - protocolo exemplo zclient)
pbrd=no 	# PBRD (PBR - gestao de regras para Police Based Routing)
bfdd=no 	# BFDD (BFD - protocolo de adjacencia instantanea)
fabricd=no 	# FABRICD (OpenFabric)
vrrpd=no 	# VRRPD (Virtual Router Redundancy Protocol Deamon)

# Como o nome diz, isso faz com que o VTYSH aplique a configuração ao iniciar aos daemons. 
vtysh_enable=yes 

# O próximo conjunto de linhas controla quais opções são passadas aos daemons quando iniciados. 
zebra_options="  -A 127.0.0.1 -s 90000000"
bgpd_options="   -A 127.0.0.1"
ospfd_options="  -A 127.0.0.1"
ospf6d_options=" -A ::1"
ripd_options="   -A 127.0.0.1"
ripngd_options=" -A ::1"
isisd_options="  -A 127.0.0.1"
pimd_options="   -A 127.0.0.1"
ldpd_options="   -A 127.0.0.1"
nhrpd_options="  -A 127.0.0.1"
eigrpd_options=" -A 127.0.0.1"
babeld_options=" -A 127.0.0.1"
sharpd_options=" -A 127.0.0.1"
pbrd_options="   -A 127.0.0.1"
staticd_options="-A 127.0.0.1"
bfdd_options="   -A 127.0.0.1"
fabricd_options="-A 127.0.0.1"
vrrpd_options="  -A 127.0.0.1"

Como este tutorial é um laboratório irei ativar os daemons OSPFv2, OSPFv3, BABEL e BGP, (em produção ative somente o necessário) pois em seguida teremos alguns exemplos contribuídos pelo Patrick Brandão.

Alterações feitas no /etc/frr/daemons vamos reiniciar o FRR

# systemctl restart frr

Verifique se o mesmo está ok

# systemctl status frr

● frr.service - FRRouting
   Loaded: loaded (/lib/systemd/system/frr.service; enabled; vendor preset: enabled)
   Active: active (running) since Tue 2020-08-11 14:00:29 -03; 41s ago
     Docs: https://frrouting.readthedocs.io/en/latest/setup.html
  Process: 665 ExecStart=/usr/lib/frr/frrinit.sh start (code=exited, status=0/SUCCESS)
   Status: "FRR Operational"
    Tasks: 18 (limit: 1150)
   Memory: 24.2M
   CGroup: /system.slice/frr.service
           ├─674 /usr/lib/frr/watchfrr -d -F traditional zebra bgpd ospfd ospf6d babeld staticd
           ├─699 /usr/lib/frr/zebra -d -F traditional -A 127.0.0.1 -s 90000000
           ├─704 /usr/lib/frr/bgpd -d -F traditional -A 127.0.0.1
           ├─712 /usr/lib/frr/ospfd -d -F traditional -A 127.0.0.1
           ├─716 /usr/lib/frr/ospf6d -d -F traditional -A ::1
           ├─720 /usr/lib/frr/babeld -d -F traditional -A 127.0.0.1
           └─724 /usr/lib/frr/staticd -d -F traditional -A 127.0.0.1

ago 11 14:00:29 frr zebra[699]: client 47 says hello and bids fair to announce only static routes vrf=0
set 23 15:44:11 accel watchfrr[1220]: zebra state -> up : connect succeeded
set 23 15:44:11 accel watchfrr[1220]: bgpd state -> up : connect succeeded
set 23 15:44:11 accel watchfrr[1220]: ospfd state -> up : connect succeeded
set 23 15:44:11 accel watchfrr[1220]: ospf6d state -> up : connect succeeded
set 23 15:44:11 accel watchfrr[1220]: staticd state -> up : connect succeeded
set 23 15:44:11 accel watchfrr[1220]: all daemons up, doing startup-complete notify
ago 11 14:00:29 frr frrinit.sh[665]: Started watchfrr.
ago 11 14:00:29 frr systemd[1]: Started FRRouting.

Pode também conferir se o serviço de cada daemons ativos foi iniciado:

# netstat -putan

Proto Recv-Q Send-Q Endereço Local          Endereço Remoto         Estado      PID/Program name    
tcp        0      0 127.0.0.1:2601          0.0.0.0:*               OUÇA       699/zebra           
tcp        0      0 127.0.0.1:2604          0.0.0.0:*               OUÇA       712/ospfd           
tcp        0      0 127.0.0.1:2605          0.0.0.0:*               OUÇA       704/bgpd            
tcp        0      0 127.0.0.1:2616          0.0.0.0:*               OUÇA       724/staticd         
tcp6       0      0 ::1:2606                :::*                    OUÇA       716/ospf6d

Lista completa das portas:

zebrasrv      2600/tcp    # zebra service
zebra         2601/tcp    # zebra vty
ripd          2602/tcp    # RIPd vty
ripngd        2603/tcp    # RIPngd vty
ospfd         2604/tcp    # OSPFd vty
bgpd          2605/tcp    # BGPd vty
ospf6d        2606/tcp    # OSPF6d vty
ospfapi       2607/tcp    # ospfapi
isisd         2608/tcp    # ISISd vty
babeld        2609/tcp    # BABELd vty
nhrpd         2610/tcp    # nhrpd vty
pimd          2611/tcp    # PIMd vty
ldpd          2612/tcp    # LDPd vty
eigprd        2613/tcp    # EIGRPd vty
bfdd          2617/tcp    # bfdd vty
fabricd       2618/tcp    # fabricd vty
vrrpd         2619/tcp    # vrrpd vty

Entrado no Shell VTY

Vtysh fornece um frontend combinado para todos os daemons FRR em uma única sessão combinada.

# vtysh

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

frr# show running-config
Building configuration...

Current configuration:
!
frr version 7.3.1
frr defaults traditional
hostname frr
log syslog informational
service integrated-vtysh-config
!
line vty
!
end
frr# exit

vtysh tem um arquivo de configuração /etc/frr/vtysh.conf que contém opções que controlam o comportamento da autenticação. Este arquivo também não será escrito por comandos de salvamento de configuração, ele deve ser atualizado manualmente.

Isso também significa que os comandos hostname e (que têm efeito para vtysh) precisam ser atualizados manualmente no vtysh.conf

Todas as configurações salvas (write) no terminal do vtysh são escritas no arquivo frr.conf.

A documentação também ressalta que é possível salvar os arquivos separados por daemons, para alterar esse comportamento é precisamos editar o /etc/frr/vtysh.conf (Fica a seu critério também, eu particularmente não altero)

# vim /etc/frr/vtysh.conf

Estão o que isso faz?
service integrated-vtysh-config
– O vtysh sempre salvará no frr.conf.

no service integrated-vtysh-config
– vtysh nunca vai salvar no frr.conf, em vez disso, ele pedirá aos daemons que escrevam/crie seus arquivos de configuração individuais.

Se fizer a altração reinicie a aplicação

# systemctl restart frr

Mais sobre vtysh: http://docs.frrouting.org/en/latest/vtysh.html

Acessamos o terminal do vtysh e usamos o comando write (salvar).

# vtysh

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

frr# write 
Note: this version of vtysh never writes vtysh.conf
Building Configuration...
Warning: /etc/frr/frr.conf.sav unlink failed
Building Configuration...
Integrated configuration saved to /etc/frr/frr.conf
[OK]
frr# exit

Na próxima vez que salvar (write) um “____.conf.sav” será criado também preservando a configuração posterior.

Você também pode acessar o terminal vtysh (zebra) por telnet, lembra que vimos as porta que cada serviço estava rodando, logo o zebra roda na porta 2601(tcp), porém responde apenas localmente (localhost/127.0.0.1) caso você deseje abrir esse acesso externamente (restringi-lo por firewall o acesso a determinados IPs é uma boa prática) faça e alteração no arquivo daemons.

# vim /etc/frr/daemons

Encontre:

zebra_options="  -A 127.0.0.1 -s 90000000"

E altere por:

zebra_options="  -A 0.0.0.0 -s 90000000"

Se você desejar alterar esta porta basta incluir “-P porta”

zebra_options="  -A 0.0.0.0 -s 90000000 -P 40023"

Salve e reinicie o FRR

# systemctl restart frr

Porém se você tentar acessar mesmo que localmente não será possível, pois uma senha não foi definida.

# telnet localhost 40023
Trying ::1...
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Vty password is not set.
Connection closed by foreign host.

Para configura as senha de login e de enable:

# vtysh

# configure terminal 
# password senha_de_login
# enable password senha_para_enable
# service password-encryption
# line vty 
# login 
# end 
# write
# exit

Ex.:

frr# configure terminal 
frr(config)# password remontti
frr(config)# enable password remontti
frr(config)# service password-encryption
frr(config)# line vty 
frr(config-line)# login 
frr(config-line)# end 
frr# write 
Note: this version of vtysh never writes vtysh.conf
Note: this version of vtysh never writes vtysh.conf
Building Configuration...
Integrated configuration saved to /etc/frr/frr.conf
[OK]
frr# exit

Faça um teste localmente ou externamente caso tenha liberado o acesso:

# telnet localhost 40023

Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.

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

User Access Verification

Password: 
frr> enable 
Password: 
frr# exit

Por mais inseguro que seja o uso do telnet, em alguns casos é comum o acesso de servidores Looking Glass publicamente. Para tornar o acesso telnet público (não vai exigir senha) apenas leitura, basta remove a senha. (Ainda assim é possível ter poderes com em enable+senha)

Removendo senha:

# configure terminal
# no password
# line vty
# no login
# end
# write
# exit

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

frr# configure terminal
frr(config)# no password
Please be aware that removing the password is a security risk and you should think twice about this command.
frr(config)# line vty
frr(config-line)# no login
frr(config-line)# end
frr# write 
Note: this version of vtysh never writes vtysh.conf
Building Configuration...
Building Configuration...
Integrated configuration saved to /etc/frr/frr.conf
[OK]
frr# exit

Zerando as configurações

Caso você queira começar tudo do zero, basta remover todos os .conf e copiar os arquivos originais que estão na pasta backup, e dar suas devidas permissões!
Ex.:

# rm /etc/frr/*.conf
# rm /etc/frr/*.sav
# rm /etc/frr/daemons
# cp /etc/frr/backups/* /etc/frr/
# chown frr. /etc/frr/ -R

Modelos de configurações:

Alguns exemplos de configurações para os daemons podem ser encontrados em:

# tree /usr/share/doc/frr/examples/
├── babeld.conf.sample
├── bfdd.conf.sample
├── bgpd.conf.sample
├── bgpd.conf.sample2
├── bgpd.conf.vnc.sample
├── eigrpd.conf.sample
├── isisd.conf.sample
├── ldpd.conf.sample
├── ospf6d.conf.sample
├── ospfd.conf.sample
├── pbrd.conf.sample
├── pimd.conf.sample
├── ripd.conf.sample
├── ripngd.conf.sample
├── staticd.conf.sample
├── vtysh.conf.sample
└── zebra.conf.sample

Em http://docs.frrouting.org/en/latest/ você encontra uma ampla documentação com muitos exemplos.

Bônus iBGP

Vou deixar aqui um modelo simples iBGP entre um servidor Linux vs Mikrotik.

Exemplo para iBGP para um DNS Anycast distribuído, usando os IPs do DNS Google, mas não estou incentivando a fazer isso é apenas um exemplo!

Configuração Linux DNS

# vtysh

Nesta configuração vamos adicionar os IPs de loopbacks em seguida fechar os peers IPv4 e IPv6, e finalizando configurando os filtros para receber rota default (Logo no RouterOS será necessário envia) e ensinar apenas as IPs de lo. Este é apenas um exemplo para você começar a brincar e estudar mais sobre o assunto.

configure terminal
!
interface lo
 ip address 8.8.8.8/32
 ipv6 address 2001:4860:4860::8888/128
!
router bgp 65530
 bgp router-id 10.1.0.2
 neighbor 10.1.0.1 remote-as 65530
 neighbor 10.1.0.1 description "iBGP_DNS_IPv4"
 neighbor 2001:db8:1::1 remote-as 65530
 neighbor 2001:db8:1::1 description "iBGP_DNS_IPv6"
 !
 address-family ipv4 unicast
  redistribute kernel
  redistribute connected
  redistribute static
  neighbor 10.1.0.1 prefix-list RR-IPV4-IN in
  neighbor 10.1.0.1 prefix-list RR-IPV4-OUT out
 exit-address-family
 !
 address-family ipv6 unicast
  redistribute kernel
  redistribute connected
  redistribute static
  neighbor 2001:db8:1::1 activate
  neighbor 2001:db8:1::1 prefix-list RR-IPV6-IN in
  neighbor 2001:db8:1::1 prefix-list RR-IPV6-OUT out
 exit-address-family
!
ip prefix-list RR-IPV4-IN seq 5 permit 0.0.0.0/0
ip prefix-list RR-IPV4-OUT seq 5 permit 8.8.8.8/32
!
ipv6 prefix-list RR-IPV6-IN seq 5 permit ::/0
ipv6 prefix-list RR-IPV6-OUT seq 5 permit 2001:4860:4860::8888/128
!
line vty
!
end
write

Configuração no Mikrotik/RouterOS (Gateway DNS)

/routing bgp instance
add client-to-client-reflection=no name=iBGP-DNS router-id=10.1.0.1

/routing bgp peer
add default-originate=always instance=iBGP-DNS name=DNS-FRR-IPv4 remote-address=10.1.0.2 remote-as=65530
add default-originate=always instance=iBGP-DNS name=DNS-FRR-IPv6 remote-address=2001:db8:1::2 remote-as=65530 address-families=ipv6

Configuração Linux Accel-PPP

# vtysh

Nesta configuração vamos fechar os peers IPv4 e IPv6, e configurar os filtros para receber rota default (Logo no RouterOS será necessário envia) e ensinar apenas as IPs possíveis ips dinâmicos desta rede (45.0.0.0/22, 100.64.0.0/10). Lembrando que este é apenas um exemplo simples para você começar a brincar e estudar mais sobre o assunto.

configure terminal
!
router bgp 65530
 bgp router-id 10.1.0.2
 neighbor 10.2.0.1 remote-as 65530
 neighbor 10.2.0.1 description "iBGP_ACCEL_IPv4"
 neighbor 2001:db8:2::1 remote-as 65530
 neighbor 2001:db8:2::1 description "iBGP_ACCEL_IPv6"
 !
 address-family ipv4 unicast
  redistribute kernel
  redistribute connected
  redistribute static
  neighbor 10.2.0.1 prefix-list FILTRO-RR-IPV4-IN in
  neighbor 10.2.0.1 prefix-list FILTRO-RR-IPV4-OUT out
 exit-address-family
 !
 address-family ipv6 unicast
  redistribute kernel
  redistribute connected
  redistribute static
  neighbor 2001:db8:2::1 activate
  neighbor 2001:db8:2::1 prefix-list FILTRO-RR-IPV6-IN in
  neighbor 2001:db8:2::1 prefix-list FILTRO-RR-IPV6-OUT out
 exit-address-family
!
ip prefix-list FILTRO-RR-IPV4-IN seq 5 permit 0.0.0.0/0
ip prefix-list FILTRO-RR-IPV4-OUT seq 5 permit 100.64.0.0/10 le 32
ip prefix-list FILTRO-RR-IPV4-OUT seq 10 permit 45.0.0.0/22 le 32
ip prefix-list FILTRO-RR-IPV4-OUT seq 15 permit 10.0.0.0/8 le 32
!
ipv6 prefix-list FILTRO-RR-IPV6-IN seq 5 permit ::/0
ipv6 prefix-list FILTRO-RR-IPV6-OUT seq 10 permit 2001:db8::/32 le 128
!
line vty
!
end
write

Configuração no Mikrotik/RouterOS (Gateway Accel-PPP)

/routing bgp instance
add client-to-client-reflection=no name=iBGP-Accel router-id=10.2.0.2

/routing bgp peer
add default-originate=always instance=iBGP-Accel name=DNS-FRR-IPv4 remote-address=10.2.0.2 remote-as=65530
add default-originate=always instance=iBGP-Accel name=DNS-FRR-IPv6 remote-address=2001:db8:2::2 remote-as=65530 address-families=ipv6

Espero que tenha lhe instigado a buscar mais sobre o FRR.

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.

Deixo aqui agradecimento ao Patrick Brandão que está elaborando um belo tutorial com muitos exemplos.

Fontes:
https://frrouting.org/
http://docs.frrouting.org/

O post Instalação do FRRouting (FRR) – Roteamento dinâmico no seu linux +Bônus iBGP apareceu primeiro em Remontti.

Servidor Looking Glass simples e rápido!

Rudimar Remontti — Fri, 27 Mar 2020 20:54:36 +0000

Um servidor Looking Glass (ou servidor LG) é muito útil para acesso remoto com o objetivo de disponibilizar informações de roteamento publicamente. O servidor atua como um portal limitado e somente leitura para roteadores de qualquer organização que esteja executando o servidor LG.

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.

Entendendo o funcionamento do FreeRadius e fazendo autenticações PPPoE, Hotspot e Wireless PSK/EAP (Lab Mikrotik/Ubiquiti)

Rudimar Remontti — Fri, 13 Mar 2020 20:33:59 +0000

Neste tutorial você irá aprender como integrar o freeradius 3.0.>16 para fazer autenticações PPPoE, Hotspot, Wireless PSK/EAP entre outras. Aprendendo mais sobre os atributos do banco de dados radius.

Para demonstrar irei criar um cenário ilustrativo de “nossa rede” com Mikrotik e Ubiquiti mas basicamente as autenticações podem serem para outras marcas. (Com algumas exceções para os atributos da Mikrotik)

Cenário ilustrativo

# Servidores
FreeRadius: 180.255.0.3

# Concentradores
MK HotSpot: 180.255.1.1
MK PPPoE: 180.255.1.3

# Torre 1 
UBNT AP1 WPA EAP: 10.0.0.2
UBNT AP2 WPA EAP: 10.0.0.3
UBNT AP3 WPA EAP: 10.0.0.4

# Torre 2 
MK AP1 WPA PSK: 10.1.0.2
MK AP2 WPA PSK: 10.1.0.3
MK AP3 WPA PSK: 10.1.0.4

Vou tomar como base a instalação do FreeRadius no tutorial: (requisito)
Criando um servidor de autenticação com FreeRadius 3.0.x no Debian Buster

Entendo as tabelas do banco de dados

• nas
A tabela NAS contém dados de hosts clientes, seria uma “substituição” do arquivo clients.conf. É muito mais fácil alimentar os hosts clientes no banco de dados do que dentro do arquivo de configuração. Então quem do nosso cenário será vamos incluir nesta tabela? Todos os equipamentos que precisarem comunicar com seu servidor para de alguma forma fazer a autenticação. Para inserir os dados na tabela nas você pode usar o terminal ou então acessando o phpMyAdmin:
Os principais campos são:
‣ nasname: IP Adress (Único)
‣ shortname: Nome (Único)
‣ type: Tipo [other]
‣ secret: Sua “senha de autorização”
‣ description: Obs

Em nosso exemplo serão os dois concentradores e os APs das torres que serão inseridos em nossa tabela nas. Ex.:

INSERT INTO `nas` (`nasname`, `shortname`, `type`, `ports`, `secret`, `server`, `community`, `description`) VALUES
-- Mikrotik PPPoE Server --
('180.255.1.1', 'RB-RouterOS-PPPoE', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'RouterOS PPPoE'),
-- Mikrotik Hotspot Server --
('180.255.1.3', 'RB-RouterOS-HotSpot', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'RouterOS HotSpot'),
-- Torre Ubiquiti --
('10.0.0.2', 'UBNT-AP-A', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'U-POP1-A'),
('10.0.0.3', 'UBNT-AP-B', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'U-POP1-B'),
('10.0.0.4', 'UBNT-AP-C', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'U-POP1-C'),
-- Torre Mikrotik  --
('10.1.0.2', 'MK-AP-A', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'M-POP2-A'),
('10.1.0.3', 'MK-AP-B', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'M-POP2-B'),
('10.1.0.4', 'MK-AP-C', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'M-POP2-B');

Algo extremamente importa é que sempre que adicionar, editar ou apagar dados da tabela NAS é necessário reiniciar o serviço FreeRadius para atualizar os hosts clientes, está é a unica tabela que é necessário um restart no serviço.

# systemctl restart freeradius

Dando continuidade as demais tabelas:

• radcheck – Armazena os registo de cada usuário com os respectivos atributos associados. Exemplo o usuário vs senha, usuário vs MAC.

• radgroupcheck – Associa atributos a um determinado grupo de usuários.

• radgroupreply – Armazena os atributos que são devolvidos a todos os usuários de um grupo.

• radusergroup – Associa um usuário a um grupo (radgroupcheck/radgroupreply) simplificando os insert em suas tabelas.

• radreply – Contém lista de atributos enviados a um único usuário.

• radpostauth – Armazena informações acerca das respostas enviadas para os usuários (Desativada).

• radacct – Se encontra toda a informação de contabilização, é dela que você consultará por exemplo um extrato de conexões, descobrir qual IP estava sendo utilizado por um usuário.

Vamos começar configurando o RouterOS/Mikrotik para fazer autenticações PPPoE (Básico)

– Criamos uma pool chamada failover (pode ser qualquer nome) nesse primeiro momento. Mais a frente veremos como configurar usando a radippool.

/ip pool
add name=failover ranges=100.100.100.0/23

– Criar um profile informando nossa pool, bem como DNS e velocidades. (Tudo isso migraremos para as tabelas mais a frente)

/ppp profile
add dns-server=8.8.8.8,8.8.4.4 local-address=180.255.1.1 name=Profile50M rate-limit=50M/50M remote-address=failover

– Criamos o PPPoE Server em uma de suas interfaces que está ouvindo os roteadores que irão “discar”, bem como informando o profile que foi
criado.

/interface pppoe-server server
add authentication=pap,chap disabled=no keepalive-timeout=30 service-name=pppoe-service default-profile=Profile50M interface=ether2

– Configuramos os usuários para serem buscado do freeradius, bem como que que o intervalo de atualização das tabelas seja de 5min.

/ppp aaa
set interim-update=5m use-radius=yes

– Adicionamos nossa conexão o servidor radius informando os tipos de autenticações que serão utilizados.

/radius
add address=180.255.0.3 secret="SEU_SECRET" service=ppp

Vamos autenticar nosso primeiro usuário o jose@provedor.com o “plano/profile” 50Mb. Para isso insira em seu banco de dados:

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('jose@provedor.com', 'Cleartext-Password', ':=', 'senha_do_usuario');

Agora configuro em nosso roteador que irá autenticar o pppoe-cliente, exemplo em um outro Mikroik:

/interface pppoe-client
add add-default-route=yes disabled=no interface=ether1 name=pppoe-out1 password=senha_do_usuario use-peer-dns=yes user=jose@provedor.com

Acessando seu concentrador já é possível ver nosso usuário jose@provedor.com autenticado:

Bom até aí nenhum mistério, mas é extremamente perigoso você ter um usuário em seu banco de dados radius sem nenhum outro atributo, pois o com apenas usuário e senha poderia ser feito qualquer autenticação sem exigir muito mais, conheço muitos sistemas que fazem isso!

Vamos supor que na conexão com o radius você tenha marcado login, e nos usuário tenha marcado para autenticar via radius (Já vi sistemas bem famosos fazerem isso!)

/radius
add address=180.255.0.3 secret="SEU_SECRET" service=ppp,login
/user aaa
set use-radius=yes

Vamos ao teste? Abra seu winbox e tente acessar seu router:

Bingo! Respiramos aliviado em ver que é apenas um usuário de leitura, mas não seria nada legal alguém acessar seu router, e além do mais esse usuário somente leitura em [AAA] –> Default Group poderia ter sido alterado para full e a M* estaria feita. Mas quem sabe você queira ter seus usuários do router no radius, então para isso precisamos pensar na segurança e adicionar outros atributos que prendam ele a este serviço. Veja como ficaria um exemplo seguro onde o atributo Service-Type prende o mesmo ao tipo Login-User, e na tabela radreply insira o atributo Mikrotik-Group informando qual o seu grupo de permissões (full/write/read/personalizada)

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'usuario_router', 'Cleartext-Password', ':=', 'senha_do_usuario'),
(NULL, 'usuario_router', 'Service-Type', '==', 'Login-User');

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'usuario_router', 'Mikrotik-Group', ':=', 'full');

Da para melhorar isso? Claro! Podemos dizer que este usuário só pode ser acessado de um determinado IP, ex.: “180.255.3.33”

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'usuario_router', 'Calling-Station-Id', '==', '180.255.3.33');

Também pode informar que este usuário só poderá acessar somente o IP deste concentrador

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'usuario_router', 'NAS-IP-Address', '==', '180.255.1.1');

Agora que já aprendemos como deixar nosso login seguro, não podemos esquecer que os o jose@provedor.com ainda consegue logar no seu router, pois ele não tem nenhum outro atributo vinculado, entendeu o perigo? Isso que não chegamos na parte do WPA-EAP, ele poderia ser utilizado lá também.

Bom para nossa segurança vamos incluir os atributos Service-Type com valor Framed-User e Framed-Protocol com valor PPP

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'jose@provedor.com', 'Service-Type', '==', 'Framed-User'),
(NULL, 'jose@provedor.com', 'Framed-Protocol', ':=', 'PPP');

E porque não prender nosso usuário ao MAC Adress dele?

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'jose@provedor.com', 'Calling-Station-Id', '==', '08:00:00:00:00:B2');

Fazendo um SELECT em nossa tabelas temos 4 atributos atrelado ao nosso usuário jose@provedor.com que deixam de certa foma muito mais seguro. Existe ainda o atributo Simultaneous-Use que falarei dele mais a frente.

MariaDB [radius]> SELECT * FROM `radcheck` WHERE `username` = 'jose@provedor.com';
+----+-------------------+--------------------+----+-------------------+
| id | username          | attribute          | op | value             |
+----+-------------------+--------------------+----+-------------------+
|  1 | jose@provedor.com | Cleartext-Password | := | senha_do_usuario  |
|  2 | jose@provedor.com | Service-Type       | == | Framed-User       |
|  3 | jose@provedor.com | Framed-Protocol    | := | PPP               |
|  4 | jose@provedor.com | Calling-Station-Id | == | 08:00:00:00:00:B2 |
+----+-------------------+--------------------+----+-------------------+
4 rows in set (0.001 sec)

Para que nosso controle de banda (queues) também seja configurado através do freeradius, o mikrotik possui uma bliblioteca Mikrotik-Rate-Limit.
Para demonstrar que realmente o jose@provedor.com não irá mais pegar os 50MB do profile irei colocar no valor 100Mb de Donw e 30 de Upload.

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'Mikrotik-Rate-Limit', ':=', '30M/100M');

Desconecte o usuário jose@provedor.com para que as novas configurações sejam atribuidas:

E se a velocidade utilizar Burst? Exemplo você quer mandar no seu plano de de 10Mb Up/50Mb Down, uma experiencia que por 1 minuto ele tenha o dobro da velocidade.

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'Mikrotik-Rate-Limit', ':=', '10M/50M 20M/100M 10M/50M 120/120 0');

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'Framed-IP-Address', ':=', '180.255.0.150');

Infelizmente o Mikrotik ainda não compreende o atributo Delegated-IPv6-Prefix (IPv6PD da LAN do cliente), no forum foram proposto algumas gambiarras pela própria mikrotik como criando script para deixar estatico os IPv6s (gambiarra que na maoria das vezes nada da certo dependendo do modelo do router) no entanto ele aceita os atributo Framed-IPv6-Prefix (IPv6 WAN) e o Mikrotik-Delegated-IPv6-Pool com o nome do da Pool que foi criada manualmente lá no seu router.

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
-- IPv6 WAN --
(NULL, 'jose@provedor.com', 'Framed-IPv6-Prefix', ':=', '2001:db8:A:B::/64'),
-- IPv6PD LAN Nome da Pool --
(NULL, 'jose@provedor.com', 'Mikrotik-Delegated-IPv6-Pool', '=', 'nome_da_pool6');

Lembrando q Delegated-IPv6-Prefix não funciona no Mikrotik (hj), oremos para que um dia seja implementado Ficaria assim:

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'Delegated-IPv6-Prefix', '=', '2001:db8:C::/56');

Se você deseja saber mais acesse o tutorial:
Como entregar IPv6+IPv4 no Mikrotik/RouterOS através de PPPoE/DHCPv6 PD e registrando os logs em um banco de dados

Entregando os DNS pelo radius, lembra que em nosso profile configuramos para entregar 8.8.8.8 e 8.8.4.4? Vamos entregar agora ao usuário jose@provedor.com os DNS 1.1.1.1 e 9.9.9.9, para isso adicione a tabela radreply os atributos MS-Primary-DNS-Server e MS-Secondary-DNS-Server.

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'MS-Primary-DNS-Server', ':=', '1.1.1.1'),
(NULL, 'jose@provedor.com', 'MS-Secondary-DNS-Server', ':=', '9.9.9.9');

Fazendo um SELECT na tabelas radreply temos 4 atributos vinculados a configurações que serão entregue ao usuário jose@provedor.com.

MariaDB [radius]> SELECT * FROM `radreply` WHERE `username` = 'jose@provedor.com';
+----+-------------------+-------------------------+----+----------------------------------+
| id | username          | attribute               | op | value                            |
+----+-------------------+-------------------------+----+----------------------------------+
|  3 | jose@provedor.com | Mikrotik-Rate-Limit     | := | 10M/50M 20M/100M 10M/50M 120/120 |
|  6 | jose@provedor.com | MS-Primary-DNS-Server   | := | 1.1.1.1                          |
|  7 | jose@provedor.com | MS-Secondary-DNS-Server | := | 9.9.9.9                          |
|  8 | jose@provedor.com | Framed-IP-Address       | := | 180.255.0.150                    |
+----+-------------------+-------------------------+----+----------------------------------+
4 rows in set (0.001 sec)

Podemos dispensar as configurações feita no profile já que o controle de banda e DNS são entregues pelo radius? Sim, porém eu particularmente deixo os DNS como uma especie de “failover” caso não seja informado, apesar que no caso do Mikrotik se o DNS não estiver informado no Profile ele irá usar o DNS do router (/ip dns). Normalmente no concentrador PPPoE eu tenho apenas um profile qual é usado para todos PPPoE Servers onde altero o Rate Limit (rx/tx) para uma velocidade extremamente baixa (100k/100k), pois assim se algum usuário autenticar e não receber as configurações de banda do radius ele estará autenticando com velocidade ilimitada.

# No seu RouteOS
/ppp profile set Profile50M rate-limit=100k/100k

Iremos ver agora como buscar nosso IPv4 através da pool do radius, tabela radippool
Vamos inserir apenas 3 entradas para demonstrar sendo 3 de IPs Validos e 3 para bloqueios. No seu caso você irá inserir todos seus IPs um a um.

INSERT INTO `radippool` 
(`pool_name`, `framedipaddress`, `calledstationid`, `callingstationid`, `username`, `pool_key`) VALUES
('pool_valido', '180.255.3.128','','','','0'),
('pool_valido', '180.255.3.129','','','','0'),
('pool_valido', '180.255.3.130','','','','0'),
('pool_bloq','100.127.0.0','','','','0'),
('pool_bloq','100.127.0.1','','','','0'),
('pool_bloq','100.127.0.2','','','','0');

Agora para testarmos vamos remover primeiro o IP 180.255.0.150 que setamos para o usuário jose@provedor.com anteriormente, pois se você utilizar o atributo Framed-IP-Address ele terá prioridade a pool.

DELETE FROM `radreply` WHERE `username` LIKE 'jose@provedor.com' AND `attribute` LIKE 'Framed-IP-Address'

Para entregar ao usuário jose@provedor.com a pool_valido utilizaremos o atributo Pool-Name

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'jose@provedor.com', 'Pool-Name', ':=', 'pool_valido');

Desconectamos nosso usuário para ver qual IP ele vai receber.

RouterOS

[usuario_router@PPP-SERVER-LAB] > ppp active print
Flags: R - radius
 #   NAME         SERVICE CALLER-ID         ADDRESS         UPTIME   ENCODING 
 0 R jose@prov... pppoe   08:00:00:00:00:B2 45.250.3.129    7m51s

Radius

MariaDB [radius]> SELECT pool_name,framedipaddress,username,pool_key FROM `radippool`;
+-------------+-----------------+-------------------+-------------------+
| pool_name   | framedipaddress | username          | pool_key          |
+-------------+-----------------+-------------------+-------------------+
| pool_valido | 45.250.3.128    |                   | 0                 |
| pool_valido | 45.250.3.129    | jose@provedor.com | 08:00:00:00:00:B2 |
| pool_valido | 45.250.3.130    |                   | 0                 |
| pool_bloq   | 100.127.0.0     |                   | 0                 |
| pool_bloq   | 100.127.0.1     |                   | 0                 |
| pool_bloq   | 100.127.0.2     |                   | 0                 |
+-------------+-----------------+-------------------+-------------------+

Podemos ver que o usuário jose@provedor.com recebeu o IP 45.250.3.129. Lembrando que esse endereço IP é entregue randomicamente, configurado lá no tutorial: Criando um servidor de autenticação com FreeRadius 3.0.x no Debian Buster
Se você quiser bloquear o cliente basta alterar sua Pool-Name para pool_bloq.

Talvez você esteja pensando: “Putz mas para cada usuário vai ter vários inserts!”. E é por isso que as tabelas radgroupcheck , radgroupreply e radusergroup existem para simplificar. É nela então que vamos criar nossos “planos”, onde podemos agrupar os atributos Service-Type, Framed-Protocol, Mikrotik-Rate-Limit, MS-Primary-DNS-Server e MS-Secondary-DNS-Server assim não sendo mais necessário informar para cada usuário.

Vamos então criar nosso Plano 10MB. Teremos um novo atributo que acho importante o uso, o Acct-Interim-Interval, ele se “equivale” ao interim-update=5m lá do mikrotik “/ppp aaa”, isso fará que se o mikrotik não atualizar os valores o freeradius solicite, em uma tradução simples é o tempo em que a tabela radacct é atualizada.

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_10MB', 'Service-Type', '==', 'Framed-User'),
('PLANO_10MB', 'Framed-Protocol', ':=', 'PPP'),
('PLANO_10MB', 'Pool-Name', ':=', 'pool_valido');

INSERT INTO `radgroupreply` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_10MB', 'Acct-Interim-Interval', ':=', '300'),
('PLANO_10MB', 'Mikrotik-Rate-Limit', ':=', '5M/10M'),
('PLANO_10MB', 'MS-Primary-DNS-Server', ':=', '9.9.9.9'),
('PLANO_10MB', 'MS-Secondary-DNS-Server', ':=', '149.112.112.112');

Aproveitando irei criar um Plano de bloqueio.

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('BLOQUEADO', 'Service-Type', '==', 'Framed-User'),
('BLOQUEADO', 'Framed-Protocol', ':=', 'PPP'),
('BLOQUEADO', 'Pool-Name', ':=', 'pool_bloq');

INSERT INTO `radgroupreply` (`groupname`, `attribute`, `op`, `value`) VALUES
('BLOQUEADO', 'Acct-Interim-Interval', ':=', '300'),
('BLOQUEADO', 'Mikrotik-Rate-Limit', ':=', '666k/666k'),
('BLOQUEADO', 'MS-Primary-DNS-Server', ':=', '8.8.8.8'),
('BLOQUEADO', 'MS-Secondary-DNS-Server', ':=', '8.8.4.4');

Para melhor entendimento e simplificar vamos apagar do usuário jose@provedor.com das tabelas radcheck e radreply.

DELETE FROM `radcheck` WHERE `username` LIKE 'jose@provedor.com';
DELETE FROM `radreply` WHERE `username` LIKE 'jose@provedor.com';

Logo nossa radcheck precisa se preocupar com apenas de dois atributos Cleartext-Password (usuário vs senha) e Calling-Station-Id (usuário vs MAC), adicionamos então:

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('jose@provedor.com', 'Cleartext-Password', ':=', 'senha_do_usuario'),
('jose@provedor.com', 'Calling-Station-Id', '==', '08:00:00:00:00:B2');

Se nesse momento o usuário conectar ele estaria sem um grupo e as configurações que estaria recebendo seriam as do profile do mikrotik (IP/DNS/Velocidade). Como fazer? Simples, você irá usar a tabela radusergroup onde você irá inserir o nome do usuário e qual o nome do grupo ele pertence. Muito mais simples não?!

INSERT INTO `radusergroup` (`username`, `groupname`) VALUES 
('jose@provedor.com', 'PLANO_10MB');

Desconecte o usuário e verifique se o mesmo irá receber as novas configurações com base em grupos.
PPPoE Server: IP Randômico [OK] / Controle de Banda [OK]

PPPoE Cliente: IP [OK] / DNS [OK]

Agora para bloquear o usuário basta fazer um UPDATE trocando o plano do usuário para BLOQUEADO.

UPDATE `radusergroup` SET `groupname` = 'BLOQUEADO' WHERE `username` LIKE 'jose@provedor.com';

Desconectamos novamente e verificamos as configurações recebidas.

Podemos ver que nossas regras estão funcionado. Vale lembrar que se for bloquear um usuário qual esteja com o atributo Framed-IP-Address onde você setou um IP fixo para o mesmo será necessário remover, caso contrario o cliente não irá receber o IP da faixa bloqueada.

Qualquer atributo que você queira que sobrescreva a radusergroup basta adicionar diretamente nas tabelas, como é o exemplo do IP fixo, vamos supor que um determinado usuário queira receber um DNS personalizado, basta adicionar o usuário dele na radreply.

Vamos ver como estão nossas tabelas até o momento:

MariaDB [radius]> SELECT * FROM `radgroupcheck`;
+----+------------+-----------------+----+-------------+
| id | groupname  | attribute       | op | value       |
+----+------------+-----------------+----+-------------+
|  1 | PLANO_10MB | Service-Type    | == | Framed-User |
|  2 | PLANO_10MB | Framed-Protocol | := | PPP         |
|  3 | PLANO_10MB | Pool-Name       | := | pool_valido |
|  4 | BLOQUEADO  | Service-Type    | == | Framed-User |
|  5 | BLOQUEADO  | Framed-Protocol | := | PPP         |
|  6 | BLOQUEADO  | Pool-Name       | := | pool_bloq   |
+----+------------+-----------------+----+-------------+
6 rows in set (0.000 sec)

MariaDB [radius]> SELECT * FROM `radgroupreply`;
+----+------------+-------------------------+----+-----------------+
| id | groupname  | attribute               | op | value           |
+----+------------+-------------------------+----+-----------------+
|  1 | PLANO_10MB | Acct-Interim-Interval   | := | 300             |
|  2 | PLANO_10MB | Mikrotik-Rate-Limit     | := | 5M/10M          |
|  3 | PLANO_10MB | MS-Primary-DNS-Server   | := | 9.9.9.9         |
|  4 | PLANO_10MB | MS-Secondary-DNS-Server | := | 149.112.112.112 |
|  5 | BLOQUEADO  | Acct-Interim-Interval   | := | 300             |
|  6 | BLOQUEADO  | Mikrotik-Rate-Limit     | := | 666k/666k       |
|  7 | BLOQUEADO  | MS-Primary-DNS-Server   | := | 8.8.8.8         |
|  8 | BLOQUEADO  | MS-Secondary-DNS-Server | := | 8.8.4.4         |
+----+------------+-------------------------+----+-----------------+
8 rows in set (0.000 sec)

MariaDB [radius]> SELECT * FROM `radcheck` WHERE `username` = 'jose@provedor.com';
+----+-------------------+--------------------+----+-------------------+
| id | username          | attribute          | op | value             |
+----+-------------------+--------------------+----+-------------------+
| 15 | jose@provedor.com | Cleartext-Password | := | senha_do_usuario  |
| 16 | jose@provedor.com | Calling-Station-Id | == | 08:00:00:00:00:B2 |
+----+-------------------+--------------------+----+-------------------+
2 rows in set (0.000 sec)

MariaDB [radius]> SELECT * FROM `radusergroup`;
+----+-------------------+-----------+----------+
| id | username          | groupname | priority |
+----+-------------------+-----------+----------+
|  1 | jose@provedor.com | BLOQUEADO |        1 |
+----+-------------------+-----------+----------+
1 row in set (0.000 sec)

Simultaneous-Use

Existe um atributo chamado Simultaneous-Use qual você pode limitar o número de vezes que aquele usuário pode autenticar, aplicando na radgroupcheck ficaria:

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_X', 'Simultaneous-Use', ':=', '1');

Porém para funcionar o Simultaneous-Use é necessário ajustes em dois arquivos:
– /etc/freeradius/3.0/sites-enabled/inner-tunnel
– /etc/freeradius/3.0/sites-enabled/default
Incluindo dentro de session o valor radutmp

session { 
    radutmp
    sql
}

Mas é extremamente importante você saber que qualquer falha de comunicação entre o roteador e o servidor a conexão ira ficar “pendurada“, como vimos na radacct todas as conexões são registradas lá, logo quando um cliente está conectado o campo de stop ainda não foi atualizado, então imagine que seu router sofreu uma falha elétrica e desligou, logo nenhuma informação será enviada para o servidor deixando todas as conexões em aberta, ao iniciar novamente o roteador todos usuários não irão conseguir logar, pois já existe uma conexão. Resumindo se você não estiver preparado para esse tipo de situação é melhor não utiliza-lo. Eu costumo deixar no pppoe server a opção one-session-per-host=yes assim apenas um login pode acessar (que vai fazer a mesma coisa) o ponto negativo é que em distintos concentradores seria possível logar. Mas se você é um cara inteligente você facilmente monta um script para verificar se o existe por exemplo dois usuários iguais na radippool vindo de diferentes nasipaddress e podendo executar uma ação, ex envia um alerta de gatonet

radippool Duplicando IPs

Um outro ponto frequente que me perguntam é sobre a radippool e o problema com duplicidades de IPs. Sim existia alguns problemas em versões mais antigas. Como no caso de uma falha elétrica ou um rompimento irá causar falha de comunicação entre servidor e concentrador. Após a versão 3.0.16 o freeradius teve alguma melhorias. Na radippool existe um campo chamado expiry_time que por padrão é de 1 hora.

Lembra que configuramos o interim-update no mikrotik e Acct-Interim-Interval na tabela radgroupreply qual montamos o “plano” com valores de 5 minutos? Logo o valor de expiry_time sempre será atualizado a cada 5 min (acrecentando o valor do lease_duration) e o prazo de expiração passará ser de +1h, porém se a falta de comunicação for por um curto tempo inferior à 1h e o mesmo usuário reautenticar ele vai manter o IP antigo pois ele ainda não expirou, e o usuário vai receber um novo IP, então o IP antigo só irá sair da tabela na próxima vez que o usuário autenticar e o prazo for maior que 1h, sabemos que uma nova autenticação pode até levar dias para acontecer novamente, e quando der um problema normalmente são muitos usuários, e com isso nossa tabelas de ips acabará facilmente ficando sem IPs livres na pool.

Oque fazer então? Este tempo pode ser ajustado no arquivo /etc/freeradius/3.0/mods-available/sqlippool na variável lease_duration = 3600, eu irei alterar para 10 min, assim será dificil algum usuário autenticar sem remover seu antigo IP alocado. Mas você pode ajustar de acordo com suas necessidades/realidade.

# sed -i 's/lease_duration = 3600/lease_duration = 600/' /etc/freeradius/3.0/mods-available/sqlippool
# systemctl restart freeradius

Algo que você pode criar é uma rotina com um script de sua linguagem preferia, fazendo um simples select na radippool e verifica se existe dois usuários, e tomando uma ação.

Porém é interessante você ajustar as querys em /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf Eu levei um bom tempo para deixar isso funcionando de forma que não tivesse mais dor de cabeça, (não irei compartilhar pois é algo que é bem para minha realidade, mais pode me chama no telegram @remontti)

Uma solução simples que encontrei para resolver isso no passado foi criar um script executado a cada 5 min no concentrador PPPoE, onde ele verifica se a conexão com o IP do servidor freeradius está respondendo, e caso não responda ele desative/ative os pppoe-servers fazendo com que os clientes desconectem (Na minha situação quando o concentrador não tem comunicação com o freeradius o cliente também não tem) assim quando estabilizar a comunicação todos irão reautenticar novamente. Tenho isso até hoje, confesso que me sinto mais confortável, caso deseje saber como ele é segue o script:

Altere 180.255.0.3 para o IP do seu servidor Freeradius. O script vai disparar 10 ping e caso não responde ele irá então desativar e ativar todos os pppoe-server. Lembre-se de não pode nenhum firewall bloqueando ICMP.

/system scheduler
add interval=5m name=checa-radius on-event="{ \r\
    \n  :local cont 0\r\
    \n  :local services [/interface pppoe-server server print count-only]\r\
    \n  /interface pppoe-server server print\r\
    \n  :if ([/ping 180.255.0.3 count=10] = 0) do={\r\
    \n    :log error message=\"COMUNICACAO RADIUS [ OFF ]\";\r\
    \n    :while (\$cont < \$services) do={\r\
    \n      /interface pppoe-server server disable numbers=\$cont\r\
    \n      /interface pppoe-server server enable numbers=\$cont\r\
    \n      :set cont (\$cont+1)\r\
    \n    }\r\
    \n  }\r\
    \n}" policy=ftp,reboot,read,write,policy,test,password,sniff,sensitive,romon start-time=startup

{ 
  :local cont 0
  :local services [/interface pppoe-server server print count-only]
  /interface pppoe-server server print
  :if ([/ping 180.255.0.3 count=10] = 0) do={
    :log error message="COMUNICACAO RADIUS [ OFF ]";
    :while ($cont < $services) do={
      /interface pppoe-server server disable numbers=$cont
      /interface pppoe-server server enable numbers=$cont
      :set cont ($cont+1)
    }
  }
}

Personalizando a alocação dos IPS para escolher uma Pool padrão quando esgotar uma Pool-Name. `Opcional`

Ao término de uma pools na maioria dos casos (provedores) subentender-se que acabou os IPs válidos e será necessários entregar IPs inválidos para fazer o CGNAT. Então porque não ajustar o allocate_find para que se caso uma Pool-Name não contenha mais IPs disponível ela lhe entregar os de uma nova Pool? Bom vale lembrar para nunca deixar a pool de bloqueio/aviso/etc faltar IPs pois se isso acontecer o cliente vai receber um IP de CGNAT. Eu particularmente gosto assim, quanto menos informação no roteador mais controle se tem.

Se desejar fazer isso vamos editar o /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf.

# vim /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

Comentando as linhas atuais da variável allocate_find:

##allocate_find = "\
##        SELECT framedipaddress FROM ${ippool_table} \
##        WHERE pool_name = '%{control:Pool-Name}' \
##        AND expiry_time IS NULL \
##        ORDER BY \
##                RAND() \
##        LIMIT 1 \
##        FOR UPDATE"

E adicionando as seguintes: (Perceba que o nome da pool alternativa/failover/backup é pool_cgnat)

allocate_find = "\
    SELECT framedipaddress FROM ${ippool_table} \
    WHERE ( \
    CASE WHEN (SELECT COUNT(framedipaddress) FROM ${ippool_table} WHERE pool_name = '%{control:Pool-Name}' AND expiry_time IS NULL LIMIT 1) > 0 THEN \
    (pool_name = '%{control:Pool-Name}' AND expiry_time IS NULL) \
    ELSE \
    (pool_name = 'pool_cgnat' AND expiry_time IS NULL) \
    END) \
    ORDER BY RAND() \
    LIMIT 1 \
    FOR UPDATE"

Lembre-se que toda a ateração nos arquivos de configurações é necessário reiniciar o serviço.

# systemctl restart freeradius

Você vai precisar adicionar agora todos seus IPs de CGNAT (cgnat.sql) ex.:

INSERT INTO `radippool` 
(`pool_name`, `framedipaddress`, `nasipaddress`, `calledstationid`, `callingstationid`, `expiry_time`, `username`, `pool_key`) VALUES
('pool_cgnat', '100.64.0.0', '', '', '', NULL, '', '0'),
('pool_cgnat', '100.64.0.1', '', '', '', NULL, '', '0'),
('pool_cgnat', '100.64.0.2', '', '', '', NULL, '', '0'),
('pool_cgnat', '100.64.0.3', '', '', '', NULL, '', '0');

Agora em seu laboratório você pode deixar apenas 1 IP válido e autenticar mais usuários para ver se a regra funcionou.

Autenticação Wireless

Conheço muitos provedores que tem apenas uma senha para todos seus POPs, ou uma diferente para cada, mas são fixas e isso é muito perigoso!!!
Vamos pensar agora só pelas piores possibilidades OK? Imagine um funcionário seu que saiu da sua empresa sabendo a senha de todas as setoriais de suas torres. Imaginou? Você pode até me dizer: "-Grande coisa ele não vai saber meus usuários e senhas dos PPPoE." Realmente ele pode não saber (mas eu nem estou preocupado com isso, pois eu prendo usuário ao MAC, agora se seu sistema não faz isso pode brotar uns gatinhos ai na rede) mas o que realmente me preocupa é o fato das "malvadezas" que podem serem feitas, vamos para primeira? Pego um NanoStation e conecto em sua setorial (para piorar essa setorial esta em bridge com mais alguma coisa... quem sabe com toda a rede?), agora que estou "dentro" da rede posso criar um pppoe-server e autenticar todas as solicitações (é só configurar para ignorar as senhas) toda vez q um um cliente solicita uma conexão um pacote broadcast é enviado na rede e quem responde primeiro ganha, posso ainda gerar um alto trafego (DDoS) bagunçar. Ai você me diz: "-Mas aqui na minha cidade o pessoal nem sabe fazer isso." Realmente, mas se esse infeliz agora pegar e conectar outro NanoStation e interligar um NanoStation no outro? Precisa ser inteligente para fazer isso? (Putz posso estar dando idéias, não faça isso com seu concorrente) Um loop esta feito, e toda essa rede vai parar de funcionar. (Conheco uma galera que usa ONUs na sua rede GPON em brid e esquece isso da para fazer também)... Parei se não vou acabar ser acusado, mas o que quero alertar é que existe uma infinidade de possibilidades ao deixar uma pessoa maliciosa conectar em sua rede.

WPA-PSK

É por isso que uma autenticação com o radius para sua rede wireless é o melhor caminho. Como isso funciona? Para cada dispositivo/antena que for conectar você terá uma senha exclusiva só para ela, vou começar explicando como fazer isso com senhas PSK com o atributo Mikrotik-Wireless-PSK da Mikrotik.

Com base no nosso diagrama da rede vamos ver como seria para autenticar o usuário joao@provedor.com, primeiramente vamos configurar nosso AP-Mikrotik.

Crie um novo profile de segurança

/interface wireless security-profiles 
add name=WPA2-PSK-Radius \
    mode=dynamic-keys management-protection=allowed \
    authentication-types=wpa2-psk radius-called-format=ssid \
    radius-mac-authentication=yes \
    wpa2-pre-shared-key=dZluej6SCdcFvRWd

Configurando a interface wireless "wlan1" setamos o security-profile para WPA2-PSK-Radius que acabamos de criar e darei o nome do sinal (ssid) de SSID-PSK-Radius.

/interface wireless
set [ find default-name=wlan1 ] \
    disabled=no mode=ap-bridge \
    security-profile=WPA2-PSK-Radius \
    ssid=SSID-PSK-Radius

Fizemos a nossa conexão com o radius, informando que vamos usar neste caso apenas o serviço wireless.

/radius
add address=180.255.0.3 secret=SEU_SECRET service=wireless

Não esqueça que sempre que adicionar um novo autenticador ao seu servidor é necessário que o mesmo seja adicionado a tabela NAS e restartado o freeradius, ex:

INSERT INTO `nas` (`nasname`, `shortname`, `type`, `ports`, `secret`, `server`, `community`, `description`) VALUES
('10.1.0.4', 'MK-AP-C', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'SSID-PSK-Radius');

# systemctl restart freeradius

Para você que está estudando é sempre deixar o radius parado e rado-lo em modo debug com o comando `freeradius -X` e observar tudo que rola. Para minha bancada estou usando um mikrotik hAp e vou tentar conectar meu celular, sem cadastrar nada no radius ainda, logo em algumas linhas veremos o seguinte:

(16)   Service-Type = Framed-User
(16)   NAS-Port-Id = "wlan1"
(16)   NAS-Port-Type = Wireless-802.11
(16)   User-Name = "44:45:4D:45:4B:4D"
(16)   Calling-Station-Id = "44-45-4D-45-4B-4D"
(16)   Called-Station-Id = "SSID-PSK-Radius"
(16)   User-Password = ""
(16)   NAS-Identifier = "MikroTik"
(16)   NAS-IP-Address = 10.1.0.4

Podemos observar que chegaram informações como o nome da interface wireless NAS-Port-Id = "wlan1", o tipo da autenticação NAS-Port-Type = Wireless-802.11, o mac do dispositivo User-Name = "44:45:4D:45:4B:4D", o nome do sinal Called-Station-Id = "SSID-PSK-Radius", o nome da router (system -> identity) NAS-Identifier = "MikroTik", e o IP NAS-IP-Address = 10.1.0.4.

Com base nessas informações vamos alimentar nossa base de dados, e é claro que pensando na segurança! Lembra criar usuário sem prender ele a outros atributos é um perigo!

Primeiro atributo então é os Mikrotik-Wireless-PSK que vamos gravar na radreply, logo nosso usuário será nosso MAC. (Estou usando o MAC Format lá do profile separado por dois pontos, mas se necessário para sua aplicação existe outros formatos `"XX XX XX XX XX XX" XX-XX-XX-XX-XX-XX XX:XX:XX:XX:XX:XX XXXX:XXXX:XXXX XXXXXX-XXXXXX XXXXXX:XXXXXX XXXXXXXXXXXX`)

INSERT INTO `radreply` (`username`, `attribute`, `op`, `value`) VALUES
('44:45:4D:45:4B:4D', 'Mikrotik-Wireless-PSK', ':=', '3ZKEG5mMq0ZRSUQy');

Na radcheck vamos então primeiro autorizar a autenticação Auth-Type (Se só gravar isso na tabela seria um perigo pois você esta autorizando esse MAC que é um usuário a autenticar mesmo sem senha) e é por isso que vamos definir que NAS-Port-Type vai ser Wireless-802.11m assim esse user só pode autenticar vindo de uma conexão wireless, e por ultimo você também pode informar que ele só irá poder conectar no SSID com nome "SSID-PSK-Radius".

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('44:45:4D:45:4B:4D', 'Auth-Type', ':=', 'Accept'),
('44:45:4D:45:4B:4D', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('44:45:4D:45:4B:4D', 'Called-Station-Id', '==', 'SSID-PSK-Radius');

Seria ainda possível prender ao Identity (NAS-Identifier) do MK, bem como o IP dele (NAS-IP-Address), mas eu acho mais complicado, mas é possível! Caso você queira que o cliente consiga se conectar em qualquer sinal basta não gravar o atributo Called-Station-Id.

WPA-EAP

No mikrotik:
Crie um novo profile de segurança, para diferenciar usarei o mac-format=XXXXXXXXXXXX. Vale lembrar que tem outras formas de configurar o EAP, mas para nosso lab podemos subi-lo da forma mais simples.

/interface wireless security-profiles
add authentication-types=wpa2-eap \
    management-protection=allowed mode=dynamic-keys \
    name=WPA2-EAP-Radius radius-called-format=ssid \
    radius-eap-accounting=yes radius-mac-format=XXXXXXXXXXXX\
    supplicant-identity=MikroTik

Ajuste sua interface

/interface wireless
set [ find default-name=wlan1 ] disabled=no \
    mode=ap-bridge security-profile=WPA2-EAP-Radius ssid=WPA2-EAP-Radius

Conecte ao radius.

/radius
add address=180.255.0.3 secret=SEU_SECRET service=wireless

No Ubiquiti (Não tem suporte PSK com Radius):

No EAP não é necessariamente ser o MAC o usuário, mas fica mais pratico até para programar, logo precisamos de um usuário e senha e prender ele ao tipo EAP. Eu particularmente NÃO uso EAP no mikrotik, por mais que PSK seja mais facil quebrar com o uso do radius fica muito complicado, e além do mais fica exclusivo ao MAC, já no EAP poderá autenticar com a mesma senha em vários dispositivos.

Inseremos então nosso user EAP no banco de dados.

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('44454D454B4D', 'Cleartext-Password', ':=', 'enIkMVfhq3WIqyKq'),
('44454D454B4D', 'Auth-Type', ':=', 'eap');

Hotspot

Vamos falar primeiro do módulo contador (sqlcounter). O módulo sqlcounter permite um contador de pacotes usando registros contábeis gravados no banco de dados.

Com este módulo é possível criar alguns cenários de interessantes no mundo do Hotspot, exemplo:
- limitar o tempo de conexão (ex.: 2h por dia/mês/único vez)

Se desejar habilite o mod sqlcounter.

# ln -s /etc/freeradius/3.0/mods-available/sqlcounter /etc/freeradius/3.0/mods-enabled/sqlcounter

Adicione em instantiate {...} dailycounter, monthlycounter e noresetcounter do arquivo /etc/freeradius/3.0/radiusd.conf

# sed -i '683i\        dailycounter' /etc/freeradius/3.0/radiusd.conf
# sed -i '684i\        monthlycounter' /etc/freeradius/3.0/radiusd.conf
# sed -i '685i\        noresetcounter' /etc/freeradius/3.0/radiusd.conf

Adicione em authorize {...} dailycounter, monthlycounter e noresetcounter do arquivo /etc/freeradius/3.0/sites-enabled/default

# sed -i '406i\        dailycounter' /etc/freeradius/3.0/sites-enabled/default
# sed -i '407i\        monthlycounter' /etc/freeradius/3.0/sites-enabled/default
# sed -i '408i\        noresetcounter' /etc/freeradius/3.0/sites-enabled/default

Restart o freeradius

# systemctl restart freeradius

Aproveitando o Mk hAp do nosso Lab vou criar um hotspot server.

Com o comando /ip hotspot setup demos um inicio a um "wizard" que fará toda as configurações automaticamente.

/ip hotspot setup  
Select interface to run HotSpot on 

hotspot interface: wlan1 #--> Defina a interface que vai rodar o server
Set HotSpot address for interface 

local address of network: 10.5.50.1/24 #--> Informe o IP/mascara da rede
masquerade network: yes #--> Ativa o NAT já para a classe
Set pool for HotSpot addresses 

address pool of network: 10.5.50.2-10.5.50.254 #--> Range da pool de IPs 
Select hotspot SSL certificate 

select certificate: no #--> Sem certificado
Select SMTP server 

ip address of smtp server: 0.0.0.0 #--> Pode deixar 0.0.0.0
Setup DNS configuration 

dns servers: 8.8.8.8,1.1.1.1 #--> Servidores DNS
DNS name of local hotspot server 

dns name: hotspot.remontti.com.br #--> Domínio qualquer (Se acessado irá mostrar o status)
Create local hotspot user 

name of local hotspot user: admin #--> Vai ser necessário criar um usuario
password for the user: admin #--> que vamos remover

Remova o usuário admin criado no wizard, defina o porfile para usar o radius e na conexão com o radius marque hotspot.

/ip hotspot user remove admin 

/ip hotspot profile
set hsprof1 use-radius=yes

/radius
add address=180.255.0.3 secret=SEU_SECRET service=hotspot

Caso você ira programar um sistema para fazer cadastro lembre-se de liberar o IP do servidor em walled-garden, assim não é necessário estar autenticado para o usuário acessar-la. Ex onde seria no mesmo serivor, irei permitir a consultas de DNS també.

/ip hotspot walled-garden ip
add action=accept disabled=no \
    dst-address=180.255.0.3 !dst-port !protocol !src-address
add action=accept disabled=no !dst-address \
    !dst-address-list dst-port=53 protocol=udp \
    !src-address !src-address-list

Com nosso AP configurado acessamos:

Vou tentar logar com tadeu@remontti.com.br com qualquer senha e visualizar no freeradius -X (debug) o que chega lá:

(6)   NAS-Port-Type = Wireless-802.11
(6)   Calling-Station-Id = "44:45:4D:45:4B:4D"
(6)   Called-Station-Id = "hotspot1"
(6)   NAS-Port-Id = "wlan1"
(6)   User-Name = "tadeu@remontti.com.br"
(6)   NAS-Port = 2151677963
(6)   Acct-Session-Id = "8040000b"
(6)   Framed-IP-Address = 10.5.50.254
(6)   Mikrotik-Host-IP = 10.5.50.254
(6)   CHAP-Challenge = 0xaf9b9672cf915d68fd7244fc43035d7a
(6)   CHAP-Password = 0x647d5c258b16ca7841803bfb3b0d376b79
(6)   Service-Type = Login-User
(6)   WISPr-Logoff-URL = "http://10.5.50.1/logout"
(6)   NAS-Identifier = "LAB"
(6)   NAS-IP-Address = 180.255.1.3

Vimos que chegaram alguns valores interessantes, podemos fazer filtro com MAC Calling-Station-Id = "44:45:4D:45:4B:4D", nome do serviço do hotspot Called-Station-Id = "hotspot1", nome da interface, nome da interface NAS-Port-Id = "wlan1" entre outros.

Agora criamos nosso usuário na tabela radcheck.

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('tadeu@remontti.com.br', 'Cleartext-Password', ':=', 'enIkMVfhq3WIqyKq');

Vamos ao teste:

100% funcionando, agora que já conhecemos os outros comandos poremos prender o usuário ao NAS-Port-Type para Wireless-802.11, criando um grupo, já vou criar 4 grupos "planos".
1º - Plano 30 minutos ao diários - Velocidade 2Mb/8Mb
3º - Plano 7 horas por mês - Velocidade 3Mb/10Mb
2º - Plano 2 Horas unica - Velocidade 8Mb/20Mb
4º - Plano Ilimitado - Velocidade 10Mb/30Mb

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('30MIN-DIA', 'Max-Daily-Session', ':=', '1800'),
('30MIN-DIA', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('7h-MES', 'Max-Monthly-Session', ':=', '25200'),
('7h-MES', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('2h-UNICA', 'Max-All-Session', ':=', '7200'),
('2h-UNICA', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('ILIMITADO', 'NAS-Port-Type', '==', 'Wireless-802.11');

INSERT INTO `radgroupreply` (`groupname`, `attribute`, `op`, `value`) VALUES
('30MIN-DIA', 'Acct-Interim-Interval', ':=', '300'),
('30MIN-DIA', 'Mikrotik-Rate-Limit', ':=', '2M/8M'),
('7h-MES', 'Acct-Interim-Interval', ':=', '300'),
('7h-MES', 'Mikrotik-Rate-Limit', ':=', '3072K/10240K'),
('2h-UNICO', 'Acct-Interim-Interval', ':=', '300'),
('2h-UNICO', 'Mikrotik-Rate-Limit', ':=', '8M/20240K'),
('ILIMITADO', 'Acct-Interim-Interval', ':=', '300'),
('ILIMITADO', 'Mikrotik-Rate-Limit', ':=', '10M/30M');

Agora vamos vincular o usuário a um grupo.

INSERT INTO `radusergroup` (`username`, `groupname`) VALUES 
('tadeu@remontti.com.br', '30MIN-DIA');

No caso dos planos com contabilidade de tempo ao término do seu tempo o login não conseguirá mais logar. Essas verificação de tempo é realizada na bom base na tabela radacct.

Um dica final é: Nunca use o mesmo freeradius para PPPoE e Hotspot, crie servidores separados, pois é muito fácil de bagunçar e qualquer inser feita indevida você pode está deixando uma brecha de segurança.

Bônus - Logs: Framed-IPv6-Prefix e Delegated-IPv6-Prefix

Só realize isso em versões antigas do freeradius, a versão do freeradius no Debian 11 por exemplo já foram implementadas as tabelas para registro de IPv6.

Em algumas autenticações (Ex accel-ppp) passam os valores de IPv6, para poder registrar os mesmo serão necessários criar os campos na radacct e ajustar o arquivo de queries.

mariadb -p -u radius

Crie dois campos framedipv6prefix e delegatedipv6prefix

USE radius;
ALTER TABLE `radacct` 
ADD `framedipv6prefix` VARCHAR(41) NULL DEFAULT NULL AFTER `framedipaddress`, 
ADD `delegatedipv6prefix` VARCHAR(41) NULL DEFAULT NULL AFTER `framedipv6prefix`;

Agora ajuste as queries em queries.conf

# vim /etc/freeradius/3.0/mods-config/sql/main/mysql/queries.conf

Vou destacar as linhas que foram alteradas, ajuste seu arquivo: (linhas 208,262-264,292-294,331-333,382-384)

# -*- text -*-
#
#  main/mysql/queries.conf-- MySQL configuration for default schema (schema.sql)
#
#  $Id: 40508024d5fd6a319bbb85775c3fe1e8388be656 $

# Safe characters list for sql queries. Everything else is replaced
# with their mime-encoded equivalents.
# The default list should be ok
#safe_characters = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /"

#######################################################################
#  Connection config
#######################################################################
# The character set is not configurable. The default character set of
# the mysql client library is used. To control the character set,
# create/edit my.cnf (typically in /etc/mysql/my.cnf or /etc/my.cnf)
# and enter
# [client]
# default-character-set = utf8
#

#######################################################################
#  Query config:  Username
#######################################################################
# This is the username that will get substituted, escaped, and added
# as attribute 'SQL-User-Name'. '%{SQL-User-Name}' should be used below
# everywhere a username substitution is needed so you you can be sure
# the username passed from the client is escaped properly.
#
# Uncomment the next line, if you want the sql_user_name to mean:
#
#	Use Stripped-User-Name, if it's there.
#	Else use User-Name, if it's there,
#	Else use hard-coded string "DEFAULT" as the user name.
#sql_user_name = "%{%{Stripped-User-Name}:-%{%{User-Name}:-DEFAULT}}"
#
sql_user_name = "%{User-Name}"

#######################################################################
# Default profile
#######################################################################
# This is the default profile. It is found in SQL by group membership.
# That means that this profile must be a member of at least one group
# which will contain the corresponding check and reply items.
# This profile will be queried in the authorize section for every user.
# The point is to assign all users a default profile without having to
# manually add each one to a group that will contain the profile.
# The SQL module will also honor the User-Profile attribute. This
# attribute can be set anywhere in the authorize section (ie the users
# file). It is found exactly as the default profile is found.
# If it is set then it will *overwrite* the default profile setting.
# The idea is to select profiles based on checks on the incoming packets,
# not on user group membership. For example:
# -- users file --
# DEFAULT	Service-Type == Outbound-User, User-Profile := "outbound"
# DEFAULT	Service-Type == Framed-User, User-Profile := "framed"
#
# By default the default_user_profile is not set
#
#default_user_profile = "DEFAULT"

#######################################################################
# NAS Query
#######################################################################
# This query retrieves the radius clients
#
# 0. Row ID (currently unused)
# 1. Name (or IP address)
# 2. Shortname
# 3. Type
# 4. Secret
# 5. Server
#######################################################################

client_query = "\
	SELECT id, nasname, shortname, type, secret, server \
	FROM ${client_table}"

#######################################################################
# Authorization Queries
#######################################################################
# These queries compare the check items for the user
# in ${authcheck_table} and setup the reply items in
# ${authreply_table}. You can use any query/tables
# you want, but the return data for each row MUST
# be in the following order:
#
# 0. Row ID (currently unused)
# 1. UserName/GroupName
# 2. Item Attr Name
# 3. Item Attr Value
# 4. Item Attr Operation
#######################################################################
# Use these for case sensitive usernames.

#authorize_check_query = "\
#	SELECT id, username, attribute, value, op \
#	FROM ${authcheck_table} \
#	WHERE username = BINARY '%{SQL-User-Name}' \
#	ORDER BY id"

#authorize_reply_query = "\
#	SELECT id, username, attribute, value, op \
#	FROM ${authreply_table} \
#	WHERE username = BINARY '%{SQL-User-Name}' \
#	ORDER BY id"

#
#  The default queries are case insensitive. (for compatibility with
#  older versions of FreeRADIUS)
#
authorize_check_query = "\
	SELECT id, username, attribute, value, op \
	FROM ${authcheck_table} \
	WHERE username = '%{SQL-User-Name}' \
	ORDER BY id"

authorize_reply_query = "\
	SELECT id, username, attribute, value, op \
	FROM ${authreply_table} \
	WHERE username = '%{SQL-User-Name}' \
	ORDER BY id"

#
#  Use these for case sensitive usernames.
#
#group_membership_query = "\
#	SELECT groupname \
#	FROM ${usergroup_table} \
#	WHERE username = BINARY '%{SQL-User-Name}' \
#	ORDER BY priority"

group_membership_query = "\
	SELECT groupname \
	FROM ${usergroup_table} \
	WHERE username = '%{SQL-User-Name}' \
	ORDER BY priority"

authorize_group_check_query = "\
	SELECT id, groupname, attribute, \
	Value, op \
	FROM ${groupcheck_table} \
	WHERE groupname = '%{${group_attribute}}' \
	ORDER BY id"

authorize_group_reply_query = "\
	SELECT id, groupname, attribute, \
	value, op \
	FROM ${groupreply_table} \
	WHERE groupname = '%{${group_attribute}}' \
	ORDER BY id"

#######################################################################
# Simultaneous Use Checking Queries
#######################################################################
# simul_count_query	- query for the number of current connections
#			- If this is not defined, no simultaneous use checking
#			- will be performed by this module instance
# simul_verify_query	- query to return details of current connections
#				for verification
#			- Leave blank or commented out to disable verification step
#			- Note that the returned field order should not be changed.
#######################################################################

simul_count_query = "\
	SELECT COUNT(*) \
	FROM ${acct_table1} \
	WHERE username = '%{SQL-User-Name}' \
	AND acctstoptime IS NULL"

simul_verify_query = "\
	SELECT \
		radacctid, acctsessionid, username, nasipaddress, nasportid, framedipaddress, \
		callingstationid, framedprotocol \
	FROM ${acct_table1} \
	WHERE username = '%{SQL-User-Name}' \
	AND acctstoptime IS NULL"

#######################################################################
# Accounting and Post-Auth Queries
#######################################################################
# These queries insert/update accounting and authentication records.
# The query to use is determined by the value of 'reference'.
# This value is used as a configuration path and should resolve to one
# or more 'query's. If reference points to multiple queries, and a query
# fails, the next query is executed.
#
# Behaviour is identical to the old 1.x/2.x module, except we can now
# fail between N queries, and query selection can be based on any
# combination of attributes, or custom 'Acct-Status-Type' values.
#######################################################################
accounting {
	reference = "%{tolower:type.%{Acct-Status-Type}.query}"

	# Write SQL queries to a logfile. This is potentially useful for bulk inserts
	# when used with the rlm_sql_null driver.
#	logfile = ${logdir}/accounting.sql

	column_list = "\
		acctsessionid,		acctuniqueid,		username, \
		realm,			nasipaddress,		nasportid, \
		nasporttype,		acctstarttime,		acctupdatetime, \
		acctstoptime,		acctsessiontime, 	acctauthentic, \
		connectinfo_start,	connectinfo_stop, 	acctinputoctets, \
		acctoutputoctets,	calledstationid, 	callingstationid, \
		acctterminatecause,	servicetype,		framedprotocol, \
        framedipaddress,    framedipv6prefix,   delegatedipv6prefix"

	type {
		accounting-on {
			#
			#  Bulk terminate all sessions associated with a given NAS
			#
			query = "\
				UPDATE ${....acct_table1} \
				SET \
					acctstoptime = FROM_UNIXTIME(\
						%{integer:Event-Timestamp}), \
					acctsessiontime	= '%{integer:Event-Timestamp}' \
						- UNIX_TIMESTAMP(acctstarttime), \
					acctterminatecause = '%{%{Acct-Terminate-Cause}:-NAS-Reboot}' \
				WHERE acctstoptime IS NULL \
				AND nasipaddress   = '%{NAS-IP-Address}' \
				AND acctstarttime <= FROM_UNIXTIME(\
					%{integer:Event-Timestamp})"
		}

		accounting-off {
			query = "${..accounting-on.query}"
		}

		start {
			#
			#  Insert a new record into the sessions table
			#
			query = "\
				INSERT INTO ${....acct_table1} \
					(${...column_list}) \
				VALUES \
					('%{Acct-Session-Id}', \
					'%{Acct-Unique-Session-Id}', \
					'%{SQL-User-Name}', \
					'%{Realm}', \
					'%{NAS-IP-Address}', \
					'%{%{NAS-Port-ID}:-%{NAS-Port}}', \
					'%{NAS-Port-Type}', \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					NULL, \
					'0', \
					'%{Acct-Authentic}', \
					'%{Connect-Info}', \
					'', \
					'0', \
					'0', \
					'%{Called-Station-Id}', \
					'%{Calling-Station-Id}', \
					'', \
					'%{Service-Type}', \
					'%{Framed-Protocol}', \
					'%{Framed-IP-Address}', \
                    '%{Framed-IPv6-Prefix}', \
                    '%{Delegated-IPv6-Prefix}')"

			#
			#  Key constraints prevented us from inserting a new session,
			#  use the alternate query to update an existing session.
			#
			query = "\
				UPDATE ${....acct_table1} SET \
					acctstarttime	= FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					acctupdatetime	= FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					connectinfo_start = '%{Connect-Info}' \
				WHERE AcctUniqueId = '%{Acct-Unique-Session-Id}'"
		}

		interim-update {
			#
			#  Update an existing session and calculate the interval
			#  between the last data we received for the session and this
			#  update. This can be used to find stale sessions.
			#
			query = "\
				UPDATE ${....acct_table1} \
				SET \
					acctupdatetime  = (@acctupdatetime_old:=acctupdatetime), \
					acctupdatetime  = FROM_UNIXTIME(\
						%{integer:Event-Timestamp}), \
					acctinterval    = %{integer:Event-Timestamp} - \
						UNIX_TIMESTAMP(@acctupdatetime_old), \
					framedipaddress = '%{Framed-IP-Address}', \
                    framedipv6prefix = '%{Framed-IPv6-Prefix}', \
                    delegatedipv6prefix = '%{Delegated-IPv6-Prefix}', \
					acctsessiontime = %{%{Acct-Session-Time}:-NULL}, \
					acctinputoctets = '%{%{Acct-Input-Gigawords}:-0}' \
						<< 32 | '%{%{Acct-Input-Octets}:-0}', \
					acctoutputoctets = '%{%{Acct-Output-Gigawords}:-0}' \
						<< 32 | '%{%{Acct-Output-Octets}:-0}' \
				WHERE AcctUniqueId = '%{Acct-Unique-Session-Id}'"

			#
			#  The update condition matched no existing sessions. Use
			#  the values provided in the update to create a new session.
			#
			query = "\
				INSERT INTO ${....acct_table1} \
					(${...column_list}) \
				VALUES \
					('%{Acct-Session-Id}', \
					'%{Acct-Unique-Session-Id}', \
					'%{SQL-User-Name}', \
					'%{Realm}', \
					'%{NAS-IP-Address}', \
					'%{%{NAS-Port-ID}:-%{NAS-Port}}', \
					'%{NAS-Port-Type}', \
					FROM_UNIXTIME(%{integer:Event-Timestamp} - %{%{Acct-Session-Time}:-0}), \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					NULL, \
					%{%{Acct-Session-Time}:-NULL}, \
					'%{Acct-Authentic}', \
					'%{Connect-Info}', \
					'', \
					'%{%{Acct-Input-Gigawords}:-0}' << 32 | '%{%{Acct-Input-Octets}:-0}', \
					'%{%{Acct-Output-Gigawords}:-0}' << 32 | '%{%{Acct-Output-Octets}:-0}', \
					'%{Called-Station-Id}', \
					'%{Calling-Station-Id}', \
					'', \
					'%{Service-Type}', \
					'%{Framed-Protocol}', \
					'%{Framed-IP-Address}', \
                    '%{Framed-IPv6-Prefix}', \
                    '%{Delegated-IPv6-Prefix}')"
		}

		stop {
			#
			#  Session has terminated, update the stop time and statistics.
			#
			query = "\
				UPDATE ${....acct_table2} SET \
					acctstoptime	= FROM_UNIXTIME(\
						%{integer:Event-Timestamp}), \
					acctsessiontime	= %{%{Acct-Session-Time}:-NULL}, \
					acctinputoctets	= '%{%{Acct-Input-Gigawords}:-0}' \
						<< 32 | '%{%{Acct-Input-Octets}:-0}', \
					acctoutputoctets = '%{%{Acct-Output-Gigawords}:-0}' \
						<< 32 | '%{%{Acct-Output-Octets}:-0}', \
					acctterminatecause = '%{Acct-Terminate-Cause}', \
					connectinfo_stop = '%{Connect-Info}' \
				WHERE AcctUniqueId = '%{Acct-Unique-Session-Id}'"

			#
			#  The update condition matched no existing sessions. Use
			#  the values provided in the update to create a new session.
			#
			query = "\
				INSERT INTO ${....acct_table2} \
					(${...column_list}) \
				VALUES \
					('%{Acct-Session-Id}', \
					'%{Acct-Unique-Session-Id}', \
					'%{SQL-User-Name}', \
					'%{Realm}', \
					'%{NAS-IP-Address}', \
					'%{%{NAS-Port-ID}:-%{NAS-Port}}', \
					'%{NAS-Port-Type}', \
					FROM_UNIXTIME(%{integer:Event-Timestamp} - %{%{Acct-Session-Time}:-0}), \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					%{%{Acct-Session-Time}:-NULL}, \
					'%{Acct-Authentic}', \
					'', \
					'%{Connect-Info}', \
					'%{%{Acct-Input-Gigawords}:-0}' << 32 | '%{%{Acct-Input-Octets}:-0}', \
					'%{%{Acct-Output-Gigawords}:-0}' << 32 | '%{%{Acct-Output-Octets}:-0}', \
					'%{Called-Station-Id}', \
					'%{Calling-Station-Id}', \
					'%{Acct-Terminate-Cause}', \
					'%{Service-Type}', \
					'%{Framed-Protocol}', \
					'%{Framed-IP-Address}', \
                    '%{Framed-IPv6-Prefix}', \
                    '%{Delegated-IPv6-Prefix}')"
		}
	}
}


#######################################################################
# Authentication Logging Queries
#######################################################################
# postauth_query	- Insert some info after authentication
#######################################################################

post-auth {
	# Write SQL queries to a logfile. This is potentially useful for bulk inserts
	# when used with the rlm_sql_null driver.
#	logfile = ${logdir}/post-auth.sql

	query =	"\
		INSERT INTO ${..postauth_table} \
			(username, pass, reply, authdate) \
		VALUES ( \
			'%{SQL-User-Name}', \
			'%{%{User-Password}:-%{Chap-Password}}', \
			'%{reply:Packet-Type}', \
			'%S')"
}

Espero que tenha aprendido um pouco mais de como o FreeRadius funciona.

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!

Fontes:
https://wiki.freeradius.org/guide/SQL-HOWTO
https://wiki.freeradius.org/modules/Rlm_sql
https://wiki.freeradius.org/modules/Rlm_sqlippool
https://wiki.freeradius.org/modules/Rlm_sqlcounter

O post Entendendo o funcionamento do FreeRadius e fazendo autenticações PPPoE, Hotspot e Wireless PSK/EAP (Lab Mikrotik/Ubiquiti) apareceu primeiro em Remontti.

Criando um servidor de autenticação com FreeRadius no Debian 10 Buster (Extra sqlippool)

Rudimar Remontti — Fri, 13 Mar 2020 20:25:16 +0000

Esse tutorial é ideal para provedores que desejam criar seu próprio sistema de autenticação com freeradius, fazendo autenticação do tipo PPPoE, hotspot, Wireless (PSK/EAP) entre outras.

Neste tutorial iremos instalar e configurar o FreeRadius 3.0.x sobre o Debina 10, com integração dos na base de dados MariaDB (frok do MySQL), ativaremos ainda o módulos SQLIPPOOL para armazenar nossa pool de IPs na base de dados.

REQUISITOS
1 – Debian 10 bustes – Instalação limpa
2 – WEB Apache + PHP + MariaDB + phpMyAdmin no Debian 10 Buster “LAMP” (Se desejar usar o phpMyAdmin)

Instalação do FreeRadius 3.0.`>17`

Primeiramente iremos criar o banco de dados e usuário e conceder as permissões de acesso.

Abra o terminal de comando do MariaDB e crie a base e o usuario chamados de radius e defina a senha para este usuário.

# mariadb -u root

Altere SENHA_USER_RADIUS. Você pode gerar uma senha forte e segura em https://senhasegura.remontti.com.br

CREATE DATABASE radius;
GRANT ALL PRIVILEGES ON radius.* TO 'radius'@'localhost' IDENTIFIED BY 'SENHA_USER_RADIUS';
FLUSH PRIVILEGES;
quit;

Instale os pacotes do freeradius

# apt install freeradius freeradius-mysql freeradius-utils

Com o o banco de dados radius criado iremos importar as tabelas padrões do freeradius:

# mariadb -u radius -p radius < /etc/freeradius/3.0/mods-config/sql/main/mysql/schema.sql
# mariadb -u radius -p radius < /etc/freeradius/3.0/mods-config/sql/ippool/mysql/schema.sql

Após comando será solicitado a senha do usuario radius (SENHA_USER_RADIUS).

Caso deseje logs mais detalhados (recomendo) edite o arquivo /etc/freeradius/3.0/radiusd.conf, mas antes faça um backup do mesmo.

# cp /etc/freeradius/3.0/radiusd.conf /etc/freeradius/3.0/radiusd.conf.orig
# vim /etc/freeradius/3.0/radiusd.conf

Localize as variáveis e altere para yes

[...]
log {
    [...]
        stripped_names = yes
        auth = yes
        auth_badpass = yes
        auth_goodpass = yes
    [...]
}
[...]

Ajustaremos o mod SQL para trabalhar com conexão do tipo mysql, e informamos os dados para conexão com o banco de dados. Arquivo /etc/freeradius/3.0/mods-available/sql.orig

# cp /etc/freeradius/3.0/mods-available/sql /etc/freeradius/3.0/mods-available/sql.orig

Usarei o comando sed para facilitar sua vida mas preste atenção nos comandos, se desejar pode editar o arquivo manualmente e alterar as entradas.

# sed -i 's/driver = "rlm_sql_null"/driver = "rlm_sql_mysql"/' /etc/freeradius/3.0/mods-available/sql
# sed -i 's/dialect = "sqlite"/dialect = "mysql"/' /etc/freeradius/3.0/mods-available/sql
# sed -i '/server = "localhost"/s/^#//g' /etc/freeradius/3.0/mods-available/sql
# sed -i '/port = 3306/s/^#//g' /etc/freeradius/3.0/mods-available/sql
# sed -i '/login = "radius"/s/^#//g' /etc/freeradius/3.0/mods-available/sql
# sed -i '/password = "radpass"/s/^#//g' /etc/freeradius/3.0/mods-available/sql
# sed -i '/read_clients = yes/s/^#//g' /etc/freeradius/3.0/mods-available/sql

No próximo comando altere SENHA_USER_RADIUS para a senha de conexão do usuário radius.

# sed -i 's/radpass/SENHA_USER_RADIUS/' /etc/freeradius/3.0/mods-available/sql

Habilite o mod:

# ln -s /etc/freeradius/3.0/mods-available/sql /etc/freeradius/3.0/mods-enabled/sql

Agora no arquivo /etc/freeradius/3.0/sites-enabled/default vamos comentar alguns componentes que não nos interessa (Se você entrar no arquivo e editar manualmente ele está todo comentado, auto explicativo.) e incluir alguns componentes como o SQL.

# cp /etc/freeradius/3.0/sites-available/default  /etc/freeradius/3.0/sites-available/default.org

# sed -i '/digest/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/suffix/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/files/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/ldap/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/exec/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/detail/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/unix/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/attr_filter.accounting_response/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i 's/-sql/sql/' /etc/freeradius/3.0/sites-available/default
# sed -i '682 s/# *//' /etc/freeradius/3.0/sites-available/default
# sed -i '829,849 {s/^/##/}' /etc/freeradius/3.0/sites-available/default

Habilitando o mod sqlippool
Como o mod sqlippool você poderá ter sua pool de IPs direto no banco de dados.

# ln -s /etc/freeradius/3.0/mods-available/sqlippool /etc/freeradius/3.0/mods-enabled/sqlippool

Vou alterar (Descomentando e comentado) a chave pool_key = "%{NAS-Port}" por "%{Calling-Station-Id}", desta forma a chave será o MAC, e "allow_duplicates = no" para não termos duplicidades de IPs. Mais adiante iremos também ajustar o allocate_clear.

# sed -i '65 {s/^/#/}' /etc/freeradius/3.0/mods-available/sqlippool
# sed -i '66 s/# *//' /etc/freeradius/3.0/mods-available/sqlippool
# sed -i '58 s/# *//' /etc/freeradius/3.0/mods-available/sqlippool

Precisamos adicionar o mod sqlippool no nosso arquivo default, você acrescentará sqlippool em accounting {...} e post-auth {...} logo abaixo de sql:

# sed -i '641i\        sqlippool' /etc/freeradius/3.0/sites-available/default
# sed -i '734i\        sqlippool' /etc/freeradius/3.0/sites-available/default

Verifique com o comando abaixo se a saída do seu arquivo ficou assim:

# cat /etc/freeradius/3.0/sites-enabled/default |grep -v "#" |awk 'NF>0'

server default {
listen {
        type = auth
        ipaddr = *
        port = 0
        limit {
              max_connections = 16
              lifetime = 0
              idle_timeout = 30
        }
}
listen {
        ipaddr = *
        port = 0
        type = acct
        limit {
        }
}
listen {
        type = auth
        port = 0
        limit {
              max_connections = 16
              lifetime = 0
              idle_timeout = 30
        }
}
listen {
        ipv6addr = ::
        port = 0
        type = acct
        limit {
        }
}
authorize {
        filter_username
        preprocess
        chap
        mschap
        eap {
                ok = return
        }
        sql
        expiration
        logintime
        pap
}
authenticate {
        Auth-Type PAP {
                pap
        }
        Auth-Type CHAP {
                chap
        }
        Auth-Type MS-CHAP {
                mschap
        }
        mschap
        eap
}
preacct {
        preprocess
        acct_unique
}
accounting {
        sql
        sqlippool
}
session {
        sql
}
post-auth {
        update {
                &reply: += &session-state:
        }
        sql
        sqlippool
        remove_reply_message_if_eap
}
pre-proxy {
}
post-proxy {
        eap
}
}

Faremos os ajustes no arquivo inner-tunnel

# cp /etc/freeradius/3.0/sites-available/inner-tunnel /etc/freeradius/3.0/sites-available/inner-tunnel.org

# sed -i '/suffix/s/^/#/g' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '/files/s/^/#/g' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '/-ldap/s/^/#/g' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i 's/-sql/sql/' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i 's/radutmp/#radutmp/' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '269 s/# *//' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '331,356 {s/^/##/}' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '365,376 {s/^/##/}' /etc/freeradius/3.0/sites-available/inner-tunnel

Verifique com o comando abaixo se a saída do seu arquivo ficou assim:

# cat /etc/freeradius/3.0/sites-enabled/inner-tunnel |grep -v "#" |awk 'NF>0'

server inner-tunnel {
listen {
       ipaddr = 127.0.0.1
       port = 18120
       type = auth
}
authorize {
        filter_username
        chap
        mschap
        update control {
                &Proxy-To-Realm := LOCAL
        }
        eap {
                ok = return
        }
        sql
        expiration
        logintime
        pap
}
authenticate {
        Auth-Type PAP {
                pap
        }
        Auth-Type CHAP {
                chap
        }
        Auth-Type MS-CHAP {
                mschap
        }
        mschap
        eap
}
session {
        sql
}
post-auth {
        sql
}
pre-proxy {
}
post-proxy {
        eap
}

Uma alteração que acho válida é para que para cada alocação de IP ela seja randômica, isso pode solucionar alguns problemas como o balanceamento dos prefixo no seu BGP, ou daqueles clientes que jogam online, fazem download e até mesmo que estão sofrendo algum ataque. Assim ao reiniciar seu equipamento o mesmo irá receber um novo endereço IP. Para que funcione desta forma iremos apenas comentar algumas linhas e descomentar outras, pois em /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf variável allocate_find já vem com o modelo pronto

Comentar:

# sed -i '41,50 {s/^/##/}' /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

##allocate_find = "\
##      SELECT framedipaddress FROM ${ippool_table} \
##      WHERE pool_name = '%{control:Pool-Name}' \
##      AND (expiry_time < NOW() OR expiry_time IS NULL) \
##      ORDER BY \
##              (username <> '%{User-Name}'), \
##              (callingstationid <> '%{Calling-Station-Id}'), \
##              expiry_time \
##      LIMIT 1 \
##      FOR UPDATE"

Descomentar:

# sed -i '55,62 s/# *//' /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

allocate_find = "\
        SELECT framedipaddress FROM ${ippool_table} \
        WHERE pool_name = '%{control:Pool-Name}' \
        AND expiry_time IS NULL \
        ORDER BY \
                RAND() \
        LIMIT 1 \
        FOR UPDATE"

Como alteramos a pool_key para Calling-Station-Id em /etc/freeradius/3.0/mods-enabled/sqlippool vamos ajustar o allocate_clear para quando for liberar um IP use a chave pool_key e não a NAS, caso contrário ira liberar IPs indevidos que estão sendo utilizado por usuários ativos e assim evitamos que surjam IPs duplicados, para isso:

Comentar:

# sed -i '26,35 {s/^/##/}' /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

##allocate_clear = "\
##      UPDATE ${ippool_table} \
##      SET \
##              nasipaddress = '', \
##              pool_key = 0, \
##              callingstationid = '', \
##              username = '', \
##              expiry_time = NULL \
##      WHERE expiry_time <= NOW() - INTERVAL 1 SECOND \
##      AND nasipaddress = '%{%{Nas-IP-Address}:-%{Nas-IPv6-Address}}'"

Descomentar

# sed -i '10,18 s/# *//' /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

allocate_clear = "\
        UPDATE ${ippool_table} \
        SET \
                nasipaddress = '', \
                pool_key = 0, \
                callingstationid = '', \
                username = '', \
                expiry_time = NULL \
        WHERE pool_key = '${pool_key}'"

É interessante você ajustar o tempo lease_duration = 3600 no arquivo /etc/freeradius/3.0/mods-available/sqlippool talvez para um menor intervalo,porém sempre respeitando que o Acct-Interim-Interval seja um tempo menor, para não ter duplicidades de ips. Falo sobre isso no tutorial https://blog.remontti.com.br/4085 recomendo a leitura!

Opcional
Eu particularmente não gosto da ideia da tabela radusergroup não ter um ID, em alguma programação ela pode ser útil, então para fazer isso se desejar faça:

# mariadb -u radius -p

Entre com suasenha do usuário radius.

USE radius;
ALTER TABLE `radusergroup` ADD `id` INT(20) NOT NULL AUTO_INCREMENT FIRST, ADD PRIMARY KEY (`id`) ;
ALTER TABLE `radusergroup` ADD UNIQUE(`id`);
quit;

Caso você tenha uma alta demanda de requisições você pode fazer algumas alterações no radiusd.conf.
Altere conforme sua necessidade, e hardware de seu servidor. Vale lembrar que fazendo essas alterações pode ser necessário alterar o limite de conexões ao MariaDB. Não abuse nessas configurações recomendo ler a documentação.

# vim /etc/freeradius/3.0/radiusd.conf

Você pode começar dobrando os valores, ex.:

[...]
thread pool {
        start_servers = 10
        max_servers = 64
        min_spare_servers = 6
        max_spare_servers = 20
        max_queue_size = 131072
        max_requests_per_server = 0
        auto_limit_acct = no
}
[...]

Finalizando

Habilite o freeradius para começar junto com a inicialização do sistema

# systemctl enable freeradius

Pare o serviço e inicie em modo debug

# systemctl stop freeradius
# freeradius -X

Se nenhum erro acontecer uma mensagem com: Ready to process requests aparecer parabéns seu freeradius está funcionando. Através do comando debug você consegue acompanhar as ações que o freeradius irá fazer, ótimo para estudos e entendimento. Para encerrar o modo debig use Crtl+c, e então inicie o serviço de forma normal.

# systemctl start freeradius

Para integrar seu servidor freeradius para fazer autenticações PPPoE, Hotspot, Wireless PSK/EAP entre outras, você precisa aprender mais sobre as tabelas do banco de dados e quais atributos usar em cada situação sempre pensando na segurança. Você pode acessar https://blog.remontti.com.br/4085 onde irá encontra alguns modelos de autenticação que atente praticamente todos os cenários de provedores.

Gostou? Quer me ajudar?

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.

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

Abraço!

Fonte:
https://wiki.freeradius.org/guide/SQL-HOWTO
https://wiki.freeradius.org/modules/Rlm_sql
https://wiki.freeradius.org/modules/Rlm_sqlippool

O post Criando um servidor de autenticação com FreeRadius no Debian 10 Buster (Extra sqlippool) apareceu primeiro em Remontti.

Proteja-se de ataques DoS/DDoS mitigando com FastNetMon e anuncie os prefixos atacados (blackholes) para sua operadora, usando Mikrotik :-)

Rudimar Remontti — Sat, 25 Jan 2020 02:28:33 +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

#
#
#
#
#
#
#
#

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" "IP $1 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" "IP $1 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" "FastNetMon: IP $1 blocked because $2 attack with power $3 pps"
    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

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

Como entregar IPv6+IPv4 no Mikrotik/RouterOS através de PPPoE/DHCPv6 PD e registrando os logs em um banco de dados

Rudimar Remontti — Wed, 22 Jan 2020 02:28:36 +0000

Neste tutorial vamos aprender como entregar IPv6 para clientes finais utilizando RouterOS/Mikrotik (Concentrador PPPoE) e registrar os logs dos prefixos IPv6 entregue na WAN (Remote IPv6 Prefix Pool) e na LAN (DHCPv6 PD Pool).

Ainda hoje encontramos alguns bugs no Mikrotik, e um dos maiores motivos de buscar essa solução foi que freeradius não registra os logs de IPv6 PD (Mikrotik), o IPv6 que vai se configurar na LAN cliente (o mais importante a ser guardado), seria muito mais fácil para muitos sistemas se implementassem o Delegated-IPv6-Prefix, mas já faz 6 anos (jan/2020) que é motivo de discussão lá no forum. E para variar a solução é dar aquele jeitinho…. (Popular gambiarra)

Para montar esse servidor de logs você precisa apenas de um serviço WEB (Apache/NGINX) PHP7+ e um banco de dados MySQL/MariaDB.

Requisito para montar um servidor do zero:
– Debian 10 Stretch / Instalação Limpa
– Como criar um servidor WEB Apache + PHP + MariaDB + phpMyAdmin no Debian 10 Buster “LAMP”

Você precisa ter um pouquinho de conhecimento em IPv6 e saber dividir as subclasses. Recomendo dar uma olhadinha no http://ipv6.nic.br/ lá irá encontrar cursos do NIC.BR.

Recomendo você instalar uma calculadora de IPv6. Aqui vai uma calculador muito boa que uso no dia a dia.

# apt install wget python-ipaddr
# wget https://blog.remontti.com.br/arquivos/Home/ip6calc -O /bin/ip6calc
# chmod +x /bin/ip6calc

Para fazer o calculo use ex.:

# ip6calc 2001:db8:abcd::/48

Para esse projeto desenvolvi em PHP alguns arquivos onde fica “ouvido” os logs que o Mikrotik irá enviar e uma telinha simples para fazer buscas dos IPs nesse banco de dados. Já disponibilizei ele lá no github.

Com seu servidor web configurado, seria bacana criar um host no seu dns e configurar nesse seu servdor web um domínio virtual ex.: log6.seudominio.com.br onde você irá jogar os arquivos do projeto. Mas como muitos não tem essa facilidade vou tentar deixar aqui a forma mais simples, que é jogar os arquivos no diretório padrão do apache “/var/www/html”, assim qualquer um consegue montar

Acessamos o diretório base então

# cd /var/www/html
# wget https://github.com/remontti/LogIPv6RouterOS/archive/master.zip
# apt install unzip
# unzip master.zip 
# mv LogIPv6RouterOS-master logs6
# cd logs6

Por segurança crie/edite um .htaccess para proteger que apenas determinados IPs tenham acesso. (apensar de ter um token)

# vim .htaccess

Altere pelo IPs que você deseja que tenham acesso. (Seus router e seu NOC)

Options -Indexes

    
        Require ip 200.200.200.0/24
        Require ip 192.168.0.0/26
        Require ip 2001:db8::/32

Precisaremos criar um banco de dados e nossa tabela. Para gerar suas senhas/token recomendo https://senhasegura.remontti.com.br/ e gerar algo aleatório.

# mariadb -p

Crie o banco de dados, não esqueça de alterar a senha (SUA_SENHA_DA_CONEXAO)

CREATE DATABASE logs6;
GRANT ALL PRIVILEGES ON logs6.* TO 'logs6'@'localhost' IDENTIFIED BY 'SUA_SENHA_DA_CONEXAO';
FLUSH PRIVILEGES;
quit;

Importe a tabela utilizando a senha criada anteriormente

# mariadb -u logs6 logs6 < logs6_mikrotik.sql -p

Agora altere no arquivo config.php o token para validar seu envio de dados e acessar o interface simples que desenvolvi para buscas, e a senha de conexão com banco (db_password).

?php
/* Your security token  */
$token = 'xxxxxxxxxxxxx';

/* Set langage */
// Portugês Brasil: pt-br
// English:  en
$lang = 'pt-br';

/* Db conect */
$db_host = 'localhost';
$db_user = 'logs6';
$db_password = 'SUA_SENHA_DA_CONEXAO';
$db_name = 'logs6';

Agora acesse sua http(s)://URL/logs6/. Você deve receber a seguinte tela.

Já pode autenticar com seu token (ainda não terá logs, então não adianta querer fazer buscas rsrsrs)

Se alguém tiver ideias melhores/criticas todas são bem vindas, sinta-se a vontade para criar forks do projeto.

Para entregar IPv6 em seu Mk é claro que precisa ter conectividade v6 em seu concentrador PPPoE (Não vou entrar em detalhes nessa parte pois entraria na questão roteamento da sua rede, mas se vale de ajuda como dica um iBGP/OSPF resolve fácil)

Servidor preparado para receber os logs vamos ao routerOS/Mikrotik. Você precisará criar duas Pool, uma para WAN outra para a LAN, como recomendação do nic.br para LAN do cliente devemos enviar um prefixo /56 (mas isso não é uma regra). A calcular pode ajudar muito nessa parte. No meu exemplo vou reservar um prefixo /48 para entregar prefixos /64 na WAN (65.536 prefixos/64), e um prefixo /45 entregando prefixos /56 oque daria 2.048 prefixos (clientes).

Ex 2001:db8:1000::/48 (WAN)

Ex 2001:db8:2000::/45 (LAN)

IPv6 -> Pool

Alteramos no profile. Menu PPP aba Profiles.

Remote IPv6 Prefix Pool selecione sua pool_wan e DHCPv6 PD Pool sua pool_lan

Na abra Protocol, Use IPv6 selecione yes.

Vamos ao pulo do gato na aba Scripts. A ideia aqui é toda vez que um PPPoE conectar ou desconectar ele execute um script. Vai ser necessário que você altere o TOKEN que você configurou lá no config.php, informe a URL (URLUP) correta que encontrará seu arquivo log6.php e em checkconnection informe o IP do seu servidor (explico o motivo a seguir).

:global TOKEN "xxxxxxxxxxxxxxxx";
:global URLUP "http://logs6.remontti.com.br/log6.php";
:global checkconnection "200.200.200.200";

A lógica é: Antes de tentar enviar as informações/valores (via post ao log6.php) fazer uma verificação se a conexão exite com o servidor de log, isso foi necessário ao simular uma "queda de energia", as vezes ele pode autenticar antes de conseguir uma conexão (se seu o usuários estiver no routerOS e ai perdemos todos os logs) nesse caso ele fica aguardando por até 5 min na tentativa (ping ao ip checkconnection) antes prosseguir, caso exista uma conexão (checkconnection) então prossegue com o script coletando as informações.

Eu aproveitei coletar IPv4 como localAddr (NAS), remoteAddr (IPv4 entregue ao cliente) isso vai facilitar também em uma analise se você quiser bater com os dados do freeradius (radacct), já aproveitei também para capturar o callerId (MAC), serviço PPP calledId. Acredito que com essas informações podem ser uteis para outros fins. Seguindo o script todo o PPPoE que subir ele vai criar um prefixo (WAN) RemoteIPv6 e em seguida precisei fazer um while que setei 60 seg para que a cada segundo ele tente identificar em /ipv6 dhcp-server binding se o cliente solicitou o prefixo que ele vai auto se configurar em sua LAN, passando por esses requisitos ele irai gerar um LOG (que você também pode estar salvando em um servidor de log remoto) e finalizando fará um fetch com os dados do binding caso ele consiga ou enviará null para a URL e assim o servidor salva-lo no banco de dados. Você verá dois logs na tela de logs, um azul quando uma conexão subir e um vermelho quando desconectar, se você desejar não ter esses logs é só remover as linha "log warning message=..... / :log error message=....."

Acesse PPP vá até a aba profile e configure os script do profile. Não esqueça de alterar as variáveis globais.

On UP

{
  :global TOKEN "xxxxxxxxxxxxxxxx";
  :global URLUP "http://________________/logs6/log6.php";
  :global checkconnection "200.200.200.200";
  :local ii 0;
  :local tt 300; # Aguarda até 5min para tentar 
  while ( $ii < $tt && ([/ping $checkconnection count=1]=0) ) do={
    :put $ii
    :set $ii ($ii + 1)
    :delay delay-time=1s
    :log error "Awaiting connection ... $checkconnection";
  }
  :local localAddr $"local-address"
  :local remoteAddr $"remote-address"
  :local callerId $"caller-id"
  :local calledId $"called-id"
  :local interfaceName [/interface get $interface name]
  :local RemoteIPv6 [/ipv6 nd prefix get value-name=prefix [find interface=$interfaceName]]
  :local i 0;
  :local x 1;  
  :local t 60; # Segundos aguardando ipv6 ser configurado no cliente
  while ($i < $t && [ :len [/ipv6 dhcp-server binding find server=$interfaceName] ] < $x) do={
    :put $i
    :set $i ($i + 1)
    :delay delay-time=1s
  }
  if ($i = $t) do={
    :log warning message="UP: $user | $callerId | $calledId | $remoteAddr | $localAddr | $RemoteIPv6 | NULL"
    /tool fetch url="$URLUP" http-data="action=i&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr&service=$calledId&ipv4=$remoteAddr&remoteipv6=$RemoteIPv6" http-method=post
  } else={
    :local DHCPv6PD [/ipv6 dhcp-server binding get value-name=address [find server=$interfaceName]]
    :log warning message="UP: $user | $callerId | $calledId | $remoteAddr | $localAddr | $RemoteIPv6 | $DHCPv6PD"
    /tool fetch url="$URLUP" http-data="action=i&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr&service=$calledId&ipv4=$remoteAddr&remoteipv6=$RemoteIPv6&dhcpv6pd=$DHCPv6PD" http-method=post
  }
  file remove log6.php
}

E ao desconectar vamos enviar ao servidor que o mesmo descontou.
On Down

{
  :global TOKEN "xxxxxxxxxxxxxxxx"
  :global URLDOWN "http://________________/logs6/log6.php"
  :local localAddr $"local-address"
  :local callerId $"caller-id"
  /tool fetch url="$URLDOWN" http-data="action=u&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr" http-method=post
  :log warning message="DOWN: $user | $callerId | $localAddr"
  file remove log6.php
}

Para concluir em IPv6 -> ND

Marque todas as opções.

No menu IP -> DNS também informe os DNS IPv6. Só assim o cliente irá aprender um DNSv6 (Advertise DNS)

Agora todo PPPoE que autenticar um log será registrado, o legal aqui é que se alguém não utiliza Radius poderá também ter um log

No arquivo log6.php que recebe os logs sempre que um usuário conectar ele irá verificar se não existe uma conexão em aberta, pois em casos de quedas de energia não vai existir tempo para ele informar que o pppoe desconectou, então ele fecha a conexão com a hora da nova conexão, logo esse IP pode ter sido utilizado por algum outro usuário, neste caso ele registra a hora que fechou a conexão com "falha" (failure), para no caso de uma investigação você observar se o mesmo ip não teve algum outro usuário que usou na horário solicitado.

Pelo phpMyAdmin também fica muito fácil de fazer buscas.

Para quem deseja bloquear um cliente IPv6, uma solução é no Router criar outra Pool6 com uma classe "invalida" por exemplo 2001:db8:6666::/48, e no freeradius usar o attibute Mikrotik-Delegated-IPv6-Pool, pode ser na tabela radreply (dizendo para qual usuário) ou para um grupo de configurações (radgroupreply) "plano".

Mikrotik:

Freeradius
Ex.: radreply

INSERT INTO `radreply` (`username`, `attribute`, `op`, `value`) VALUES
('nome_user', 'Mikrotik-Delegated-IPv6-Pool', '=', 'ipv6_drop');

Ex.: radgroupreply

INSERT INTO `radgroupreply` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_BLOQUEADO', 'Mikrotik-Delegated-IPv6-Pool', '=', 'ipv6_drop');

Desta forma o routerOS interpretará o nome da pool pelo atriburo Mikrotik-Delegated-IPv6-Pool, e assim que o cliente logar ele não pegará do bloco válido. Até poderia usar uma válido e bloquear no firewall (mas isso é coisa de sistema amador #ficadica).

Se seu freradius é antigo (v2.x) precisará ter o dictionary atualizado.

Vou deixar um exemplo de como configurar um pppoe cliente em um mikrotik, já que percebi um bug quando ele precisa renovar seu IPv6.

/interface pppoe-client
add add-default-route=yes disabled=no interface=ether1 name=pppoe-out1 password=SENHA use-peer-dns=yes user=SENHA

/ipv6 dhcp-client
add interface=pppoe-out1 pool-name=DHCPv6PD pool-prefix-length=56 request=prefix

/ipv6 address
add advertise=yes from-pool=DHCPv6PD interface=INTERFACE_LAN

/ppp profile
set *0 on-up="{\r\
    \n  /delay delay-time=5s\r\
    \n  /ipv6 dhcp-client renew numbers=0\r\
    \n  /delay delay-time=2s\r\
    \n  /ipv6 dhcp-client renew numbers=0\r\
    \n}"
/ipv6 firewall mangle
add action=change-mss chain=forward new-mss=clamp-to-pmtu passthrough=yes \
    protocol=tcp tcp-flags=syn

Gambiarazinha no profile para renovar o IP sem dor de cabeça toda vez que ele autenticar (bugs)

{
  /delay delay-time=5s
  /ipv6 dhcp-client renew numbers=0
  /delay delay-time=2s
  /ipv6 dhcp-client renew numbers=0
}

Gostou? Espero que você consiga implementar seu IPv6 e esteja seguro com os logs armazenado!

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!

RouterOS v7

Descomente os # :log warning "DEBUG>...." se precisar debugar o script, ou remova para deixar mais enxuto o script.

{
  # :log warning "DEBUG> UP: Iniciando o script logs6";
  :global TOKEN "xxxxxxxxxxxxxxxx";
  :global URLUP "http://logs6.remontti.com.br/log6.php";
  :global checkconnection "10.0.0.1";
  :local ii 0;
  :local tt 60;
  while ( $ii < $tt && ([/ping $checkconnection count=1]=0) ) do={
    :put $ii
    :set $ii ($ii + 1)
    :delay delay-time=1s
    :log error "Aguardando conexao com servidor... $checkconnection";
  }
  :local localAddr $"local-address"
  # :log warning "DEBUG> localAddr = $localAddr";
  :local remoteAddr $"remote-address"
  # :log warning "DEBUG> remoteAddr = $remoteAddr";
  :local callerId $"caller-id"
  # :log warning "DEBUG> callerId = $callerId";
  :local calledId $"called-id"
  # :log warning "DEBUG> calledId = $calledId";
  :local userName $"user"
  # :log warning "DEBUG> userName = $userName";
  :local interfaceID $"interface"
  # :log warning "DEBUG> interfaceID = $interfaceID";
  :local interfaceName [/interface get $interfaceID name]  
  # :log warning "DEBUG> interfaceName = $interfaceName";
  :local RemoteIPv6 [/ipv6 nd prefix get value-name=prefix [find interface=$interfaceName]]
  # :log warning "DEBUG> RemoteIPv6 = $RemoteIPv6";
  :local i 0;
  :local x 1;  
  :local t 60;
  while ($i < $t && [ :len [/ipv6 dhcp-server binding find server=$interfaceName] ] < $x) do={    
    :put $i    
    :set $i ($i + 1)
    :delay delay-time=1s
    # :log warning "DEBUG> Aguardando IPv6 da LAN de $userName ($i)s";
  }
  :local file [/file find name="log6.php"]
  :if ([:len $file] > 0) do={
      /file remove log6.php
  }  
  if ($i = $t) do={
    # :log warning "DEBUG> IPv6 LAN: não descoberto descoberto";
    :log warning message="UP: $user | $callerId | $calledId | $remoteAddr | $localAddr | $RemoteIPv6 | NULL"
    # :log warning "DEBUG> Executando fetch UP: $URLUP http-data=action=i&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr&service=$calledId&ipv4=$remoteAddr&remoteipv6=$RemoteIPv6 http-method=post"
    /tool/fetch url="$URLUP" http-data="action=i&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr&service=$calledId&ipv4=$remoteAddr&remoteipv6=$RemoteIPv6" http-method=post
  } else={    
    :local DHCPv6PD [/ipv6 dhcp-server binding get value-name=address [find server=$interfaceName]]
    # :log warning "DEBUG> IPv6 LAN: Descoberto descoberto $DHCPv6PD";
    :log warning message="UP: $user | $callerId | $calledId | $remoteAddr | $localAddr | $RemoteIPv6 | $DHCPv6PD"
    # :log warning "DEBUG> Executando fetch UP: $URLUP http-data=action=i&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr&service=$calledId&ipv4=$remoteAddr&remoteipv6=$RemoteIPv6&dhcpv6pd=$DHCPv6PD http-method=post";
    /tool/fetch url="$URLUP" http-data="action=i&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr&service=$calledId&ipv4=$remoteAddr&remoteipv6=$RemoteIPv6&dhcpv6pd=$DHCPv6PD" http-method=post
  }
  :delay delay-time=1s
  # :log warning "DEBUG> Removendo arquivo log6.php";
  :local file [/file find name="log6.php"]
  :if ([:len $file] > 0) do={
      /file remove log6.php
  }
  # :log warning "DEBUG> Script concluído."
}

DOWN

{
  # :log warning "DEBUG> DOWN: Iniciando o script logs6";
  :global TOKEN "xxxxxxxxxxxxxxxx"
  :global URLDOWN "http://logs6.remontti.com.br/log6.php"
  :local localAddr $"local-address"
  # :log warning "DEBUG> localAddr = $localAddr";
  :local callerId $"caller-id"
  # :log warning "DEBUG> calledId = $calledId";
  :local file [/file find name="log6.php"]
  :if ([:len $file] > 0) do={
      /file remove log6.php
  }  
  # :log warning "DEBUG> Executando fetch DOWN: $URLDOWN http-data=action=u&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr http-method=post";
  /tool/fetch url="$URLDOWN" http-data="action=u&token=$TOKEN&user=$user&mac=$callerId&nas=$localAddr" http-method=post
  :log warning message="DOWN: $user | $callerId | $localAddr"
  :delay delay-time=1s
  # :log warning "DEBUG> Removendo arquivo log6.php";
  :local file [/file find name="log6.php"]
  :if ([:len $file] > 0) do={
      /file remove $file
  }
  # :log warning "DEBUG> Script concluído."
}

O post Como entregar IPv6+IPv4 no Mikrotik/RouterOS através de PPPoE/DHCPv6 PD e registrando os logs em um banco de dados apareceu primeiro em Remontti.

Criando backup do RouterOS/Mikrotik via FTP

Rudimar Remontti — Wed, 18 Dec 2019 00:40:00 +0000

Neste exemplo vou ensinar como fazer um backup do seu routerOS/Mikroitk via FTP.

Testei com as versões > 6.48.x e > 7.6

Requisitos ter um servidor FTP
Sugestão: Como criar um servidor FTP (Pure-FTPd) com usuário no banco de dados (MariaDB) usando Debian 10

Vamos ao script, você precisa alterar:
:global host ____IP/DNS_SERVIDOR_FTP____
:global usuario ____USER____
:global senha ____SENHA____
:global diretorio ____pastaX____

Acesse o menu: System >> Script e depois em [+]

O nome do arquivo será o mesmo que você definiu em System >> Identity, serão criado dois arquivos, uma backup e um export (AAAA-MM-DD.NOME.backup AAAA-MM-DD.NOME.rsc)

:log warning "***************************************"
# Conexão FTP
:global host ____IP/DNS_SERVIDOR_FTP____
:global usuario ____USER____
:global senha ____SENHA____
:global diretorio ____pastaX____
# Pega o nome do Router
:global identifica [/system identity get name ];
# Gera data no formato AAAA-MM-DD
:global data [/system clock get date]
:global meses ("jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec");
:global ano ([:pick $data 7 11])
:global mestxt ([:pick $data 0 3])
:global mm ([ :find $meses $mestxt -1 ] + 1);
:if ($mm < 10) do={ :set mm ("0" . $mm); }
:global mes ([:pick $ds 7 11] . $mm . [:pick $ds 4 6])
:global dia ([:pick $data 4 6])
:log info "Gerando backup: $ano-$mes-$dia.$identifica.backup";
/system backup save name="$ano-$mes-$dia.$identifica";
:log info "Gerando export: $ano-$mes-$dia.$identifica.rsc";
/export file="$ano-$mes-$dia.$identifica"
:log info "Processando...";
:delay 5s
:log info "Conectando FTP Server...";
:log info "Enviando Backup [$ano-$mes-$dia.$identifica.backup] ...";
/tool fetch address=$host src-path="$ano-$mes-$dia.$identifica.backup" user="$usuario" password="$senha" port=21 upload=yes mode=ftp dst-path="$diretorio/$ano-$mes-$dia.$identifica.backup"
:log info "Enviando Export [$ano-$mes-$dia.$identifica.rsc] ...";
/tool fetch address=$host src-path="$ano-$mes-$dia.$identifica.rsc" user="$usuario" password="$senha" port=21 upload=yes mode=ftp dst-path="$diretorio/$ano-$mes-$dia.$identifica.rsc"
:delay 1
:log info "Backup enviado com sucesso...";
:log info "Removendo arquivos...";
 /file remove "$ano-$mes-$dia.$identifica.backup"
 /file remove "$ano-$mes-$dia.$identifica.rsc"
:log info "Rotina de backup finalizada...";
:log warning "***************************************";

Agora será preciso agenda-lo para execução a cada X período, no meu exemplo vou definir que todos os meio dias a cada 3 dias. Ajuste de acordo com suas necessidades:
Acesse o menu: System >> Scheduler [+]

Se estiver com preguiça pode copiar as linhas abaixo e colar no terminal, depois só alterar as variáveis.

/system script
add dont-require-permissions=no name=backup_ftp owner=remontti policy=ftp,reboot,read,write,policy,test,password,sniff,sensitive,romon source=":log warning \"***************************************\"\r\
    \n# Conex\E3o FTP\r\
    \n:global host ____IP/DNS_SERVIDOR_FTP____\r\
    \n:global usuario ___USUARIO___\r\
    \n:global senha ___SENHA___\r\
    \n:global diretorio ___NOME_DA_PASTA___\r\
    \n# Pega o nome do Router\r\
    \n:global identifica [/system identity get name ];\r\
    \n# Gera data no formato AAAA-MM-DD\r\
    \n:global data [/system clock get date]\r\
    \n:global meses (\"jan\",\"feb\",\"mar\",\"apr\",\"may\",\"jun\",\"jul\",\"aug\",\"sep\",\"oct\",\"nov\",\"dec\");\r\
    \n:global ano ([:pick \$data 7 11])\r\
    \n:global mestxt ([:pick \$data 0 3])\r\
    \n:global mm ([ :find \$meses \$mestxt -1 ] + 1);\r\
    \n:if (\$mm < 10) do={ :set mm (\"0\" . \$mm); }\r\
    \n:global mes ([:pick \$ds 7 11] . \$mm . [:pick \$ds 4 6])\r\
    \n:global dia ([:pick \$data 4 6])\r\
    \n:log info \"Gerando backup: \$ano-\$mes-\$dia.\$identifica.backup\";\r\
    \n/system backup save name=\"\$ano-\$mes-\$dia.\$identifica\";\r\
    \n:log info \"Gerando export: \$ano-\$mes-\$dia.\$identifica.rsc\";\r\
    \n/export file=\"\$ano-\$mes-\$dia.\$identifica\"\r\
    \n:log info \"Processando...\";\r\
    \n:delay 5s\r\
    \n:log info \"Conectando FTP Server...\";\r\
    \n:log info \"Enviando Backup [\$ano-\$mes-\$dia.\$identifica.backup] ...\";\r\
    \n/tool fetch address=\$host src-path=\"\$ano-\$mes-\$dia.\$identifica.backup\" user=\"\$usuario\" password=\"\$senha\" port=21 upload=yes mode=ftp dst-path=\"\$diretorio/\$ano-\$mes-\$dia.\$identifica.backup\"\
    \r\
    \n:log info \"Enviando Export [\$ano-\$mes-\$dia.\$identifica.rsc] ...\";\r\
    \n/tool fetch address=\$host src-path=\"\$ano-\$mes-\$dia.\$identifica.rsc\" user=\"\$usuario\" password=\"\$senha\" port=21 upload=yes mode=ftp dst-path=\"\$diretorio/\$ano-\$mes-\$dia.\$identifica.rsc\"\r\
    \n:delay 1\r\
    \n:log info \"Backup enviado com sucesso...\";\r\
    \n:log info \"Removendo arquivos...\";\r\
    \n /file remove \"\$ano-\$mes-\$dia.\$identifica.backup\"\r\
    \n /file remove \"\$ano-\$mes-\$dia.\$identifica.rsc\"\r\
    \n:log info \"Rotina de backup finalizada...\";\r\
    \n:log warning \"***************************************\";"

/system scheduler
add interval=3d name=backup_ftp on-event=backup_ftp policy=ftp,reboot,read,write,policy,test,password,sniff,sensitive start-date=dec/17/2019 start-time=12:00:00

Simples né! 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 Criando backup do RouterOS/Mikrotik via FTP apareceu primeiro em Remontti.

Instalação do Elastic Stack 7 + ElastiFlow no Debian 10 Buster (Bônus Traffic Flow Mikrotik/RouterOS)

Rudimar Remontti — Fri, 16 Aug 2019 18:06:41 +0000

Para um tutorial mais atualizado acesse: https://blog.remontti.com.br/6255

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.

timepicker:

[
  {
    "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.

Servidor de log para registros remoto do RouterOS/Mikrotik Huawei entre outros fabricantes

Rudimar Remontti — Wed, 12 Sep 2018 13:22:10 +0000

Neste tutorial vamos ver como configurar um servidor de logs para coletar logs de roteadores Mikrotik/RouterOS, porém o mesmo pode ser usado para qualquer roteador/servidor.

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

Handling 1 logs

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.

Acessando logs do rsyslog via web com Log Analyzer

Rudimar Remontti — Wed, 12 Sep 2018 09:05:47 +0000

O projeto LogAnalyzer já é antigo, não tem um interface muito bonita mas fornece um frontend fácil de usar e poderoso, permite pesquisar, revisar e analisar dados de eventos de rede, incluindo syslog. É um aplicativo gratuito de código aberto GPL escrito principalmente em php. Os dados podem ser obtidos de bancos de dados, mas também de arquivos de texto simples, por exemplo, aqueles que são escritos pelo rsyslog.

Para dar inicio vamos precisar ter um serviço Web rodado em nosso servidor
Requisitos: Passo-a-passo como criar um servidor web Apache2, PHP 7.0, MariaDB, PHPMyAdmin “LAMP” no Debian 9 Stretch

Sugerido: Servidor de log para registros remoto do RouterOS/Mikrotik

Agora já com nosso servidor LAMP pronto vamos criar nossa base de dados chamada Syslog (sim com S maiúsculo) e criar o usuario rsyslog para acessar esse banco.

# mysql -p

CREATE DATABASE Syslog;
GRANT ALL PRIVILEGES ON Syslog.* TO 'rsyslog'@'localhost' IDENTIFIED BY 'SUA-SENHA';
FLUSH PRIVILEGES;
quit;

Instalaremos o modulo rsyslog-mysql para fazer a integração

# apt install rsyslog-mysql

Responda Sim

Informe a senha criada para o usuário rsyslog (‘rsyslog’@’localhost’ IDENTIFIED BY ‘SUA-SENHA’)

Repita a senha

Verifique se o arquivo /etc/rsyslog.d/mysql.conf foi criado

cat /etc/rsyslog.d/mysql.conf

Vai retornar:

	$ModLoad ommysql
	*.* :ommysql:localhost,Syslog,rsyslog,SUA-SENHA

Agora reinicie o serviço do rsyslog para atualizar as configurações

# /etc/init.d/rsyslog restart

Pronto seu rsyslog já esta guardado todos os logs no seu banco de dados, agora vamos a instalação e configuração do LogAnalyzer

Na data de hoje o projeto encontra-se na versão 4.1.6
Acesse https://loganalyzer.adiscon.com/download/ e verifique se já não existe uma nova versão.

Nos comandos a seguir vamos fazer o download do projeto, em seguida extrair o mesmo, e mover o projeto para dentro da pasta padrão do servidor web (/var/www/html/) faça de acordo com sua realidade, e ultimo estaremos dando permissões ao usuário apache (www-data) a escrever nos arquviso .

# cd /tmp/
# wget http://download.adiscon.com/loganalyzer/loganalyzer-4.1.6.tar.gz
# tar -vxzf loganalyzer-4.1.6.tar.gz
# cd loganalyzer-4.1.6/
# mv src/ /var/www/html/logs
# chown www-data. /var/www/html/logs -R

Existe um pacote de tradução, porém o mesmo não foi traduzido, caso tenha interesse em baixar, e fazer a tradução:

# cd /tmp/
# wget https://loganalyzer.adiscon.com/plugins/files/translations/loganalyzer_lang_pt_BR_3.2.3.zip
# apt install  unzip
# unzip loganalyzer_lang_pt_BR_3
# unzip loganalyzer_lang_pt_BR_3.2.3.zip
# mv pt_BR /var/www/html/logs/lang/
# chown www-data. /var/www/html/logs -R

Agora acesse: http://SEU-IP_OU-DOMINIO/logs/

Vamos ser avisados que o sistema precisa ser instalado/configurado. Clique em “here”.

Next

Next

Selecione YES em Enabled User Database, e configure em Database User o usuário rsyslog e sua senha.

Next

Se não tiver nenhum erro, clique em next.

Crie um usuário e senha para o administrador

Crie uma fonte de coleta, no nosso caso vamos usar os logs do mysql, siga de acordo com a imagem. Posteriormente você pode criar outras fontes.

Next

Parabéns você concluiu!

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 Acessando logs do rsyslog via web com Log Analyzer apareceu primeiro em Remontti.