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.

CREATOR: gd-jpeg v1.0 (using IJG JPEG v62), quality = 82

Existem várias ferramentas de virtualização disponíveis.

Microsoft Virtual Server 2005 R2 – disponível para plataforma x86 e x86_64 bits. Suporte: Somente Windows.
Qemu – ferramenta de virtualização de código aberto disponível para windows, mac e Linux.
Vmware – Disponível para Windows e Linux.
VirtualBox – Aplicativo de código aberto disponível para Windows, Mac, Linux e Solaris.
Xen – Suporta Windows, bem como distribuições Linux.

O VirtualBox inicialmente foi lançado sob licença proprietária, mas mais tarde (2007) a Oracle Corporation começou a lançá-lo sob GNU General Public License. Escrito completamente em C, C ++ e Assembly Language está disponível para Windows, OS X, Linux e Solaris.

Recomendo já baixar a ISO nonfree: https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/

Requerimentos

Debian 11 (Bullseye) 64 bits instalação mínima pronta

Acesse seu servidor e vire root.

# su - 

Certifique-se que seu repositório esteja usando os repositórios nonfree e contrib.

# vim /etc/apt/sources.list

Ao final de cada linha verifique se consta: nonfree e contrib, se não tiver adicione, ficando assim:

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/updates main contrib non-free
deb-src http://security.debian.org/debian-security bullseye/updates main contrib non-free

# bullseye-updates, previously known as 'volatile'
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
# apt install firmware-linux firmware-linux-free firmware-linux-nonfree

Vamos fazer uns ajustes nas parametrizações do kernel para otimizar algumas coisas.

# echo "vm.swappiness=10" >> /etc/sysctl.conf
# echo "vm.vfs_cache_pressure=50" >> /etc/sysctl.conf
# echo "vm.dirty_background_ratio = 5" >> /etc/sysctl.conf
# echo "vm.max_map_count=262144" >> /etc/sysctl.d/70-vbox.conf
# echo "fs.file-max=3263776" >> /etc/sysctl.d/70-vbox.conf
# echo "fs.aio-max-nr=3263776" >> /etc/sysctl.d/70-vbox.conf

# cat <<EOF >/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
net.core.default_qdisc = fq
net.core.somaxconn = 16384
EOF

Se desejar que seu servidor tenha os nomes de interfaces como: eth0 eth1… wlan0 wlan1… faça um ajuste no grub:
OBS: Será necessário que você reconfigure a placa de rede (/etc/network/interfaces)

# vim /etc/default/grub

Ajuste GRUB_CMDLINE_LINUX_DEFAULT

GRUB_CMDLINE_LINUX_DEFAULT="quiet net.ifnames=0 biosdevname=0"

# update-grub

Adicione o repositório do virtualbox

# apt install wget vim apt-transport-https gnupg
# echo 'deb [arch=amd64 signed-by=/usr/share/keyrings/oracle-virtualbox-2016.gpg] https://download.virtualbox.org/virtualbox/debian bullseye contrib' > /etc/apt/sources.list.d/virtualbox.list
# wget -O- https://www.virtualbox.org/download/oracle_vbox_2016.asc | gpg --dearmor --yes --output /usr/share/keyrings/oracle-virtualbox-2016.gpg

Reinicia a máquina para carregar os novos módulos do kernel.

# apt update
# apt install virtualbox-7.0
# reboot

Acesse seu servidor novamente e vire root.

# su - 

Faça download dos pacotes extras:

# cd /tmp/ 
# wget https://download.virtualbox.org/virtualbox/7.0.8/Oracle_VM_VirtualBox_Extension_Pack-7.0.8.vbox-extpack

Caso esteja atualizando remova as versões mais antigas:

# VBoxManage extpack uninstall "Oracle VM VirtualBox Extension Pack"

Instale os pacotes extras

# VBoxManage extpack install Oracle_VM_VirtualBox_Extension_Pack-7.0.8.vbox-extpack

Responta Yes (y)

Vamos executá-lo como o nosso usuário vbox, porque ele não precisa acessar o resto do seu sistema.

# useradd -d /home/vbox -m -g vboxusers -s /bin/bash vbox

Defina uma senha para seu usuario vbox

# passwd vbox

Diga ao seu sistema qual usuário vai executar o VirtualBox.

# echo 'VBOXWEB_USER=vbox' > /etc/default/virtualbox 
# echo 'VBOXWEB_HOST=127.0.0.1' >> /etc/default/virtualbox

Faça com que o vboxweb-service inicie no boot. Como dito acima nosso usuário não precisa ter acesso total ao sistema. Adicione no /etc/rc.local o comando para iniciar junto com o boot.

# vim /etc/rc.local

Adicione

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.
#
# Solução para inicialização automatica:
# use o comando la listar as VMs criadas
# su - vbox --shell=/bin/bash -c 'VBoxManage list vms'
# Colete as ID
# "Debian" {d288884d-a3d4-4903-b84e-5c6039af13b5}
# Pegue o "ID" da VM e use o Comando a baixo descomentando a linha:
#
# Adicione um sleep para aguardar 30seg para dar tempo do modulo do kernel ter tempo de iniciar
# sleep 30
# su - vbox --shell=/bin/bash -c 'VBoxHeadless -s d288884d-a3d4-4903-b84e-5c6039af13b5 &'
#
#
exit 0

Alterare as permissões:

# chmod +x /etc/rc.local
# ln -s /lib/systemd/system/rc-local.service /etc/systemd/system/rc-local.service

Vamos instalar o serviço web + php

Será necessário PHP8, Para isso adicione ao repositório:

# wget -qO - https://packages.sury.org/php/apt.gpg | apt-key add -
# echo "deb https://packages.sury.org/php/ bullseye main" | tee /etc/apt/sources.list.d/sury-php.list
# apt update

Instale o Apache+PHP

# apt install apache2 libapache2-mod-php\
 php-cli php-bcmath php-gmp php-mbstring php-zip php-curl\
 php php-common php-soap php-gd unzip php-pear php-xml php-soap

Por segurança recomendo remover a assinatura do servidor, para isso:

# sed -i 's/ServerTokens OS/ServerTokens Prod/' /etc/apache2/conf-available/security.conf
# sed -i 's/ServerSignature On/ServerSignature Off/' /etc/apache2/conf-available/security.conf

Vamos também configurar nosso domínio virtual para acessar o servidor via domínio (ex vbox.remontti.com.br) e restringir ele apenas para nossos IP de gerencia.

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

Faça as devidas alterações, não esqueça de alterar em Require ip para os IPs que você vai autorizar as conexões.

<virtualhost *:80>
        Protocols h2 http/1.1
        ServerName vm.remontti.com.br
        ServerAdmin noc@remontti.com.br
        ErrorDocument 403 http://www.remontti.com.br/
 
        DocumentRoot /var/www/html
 
        <Directory /var/www/html/>
                Options FollowSymLinks
                AllowOverride All
                Require ip 127.0.0.1 ::1 192.168.0.0/16 172.16.0.0/12 100.64.0.0/10 10.0.0.0/8 250.0.0.0/22 2000:000::/32
        </Directory>
 
        LogLevel warn 
        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</virtualhost>

Habilite os módulos

# a2enmod http2
# systemctl restart apache2

phpVirtualbox

O phpVirtualbox oficial até a data desta publicação (abril/2022) a versão 5.2, porém ela já não é mais instalável no Debian 11, então iremos utilizar um fork compatível com o phpVirtualbox 7.0

Vamos configurar o projeto phpvirtualbox by Bartek Sz., dentro do diretório padrão do apache.

# cd /var/www/
# mv /var/www/html/ /var/www/html_old
# wget https://github.com/BartekSz95/phpvirtualbox/archive/main.zip -O phpvirtualbox.zip
# apt install zip unzip
# unzip phpvirtualbox.zip
# mv phpvirtualbox-main html
# rm phpvirtualbox.zip
# chown vbox:vboxusers html  -R
# cd /var/www/html/
# cp config.php-example config.php
# vim config.php

 // ... //
var $username = 'vbox';
var $password = 'pass';
// ... //
var $language = 'pt_br';
var $vrdeports = '9000-9100';
var $vrdeaddress = '0.0.0.0';
// ... //
var $enableAdvancedConfig = true; 

É altamente recomendado que você tenha um firewall em cima da range de portas 9000 a 9100, pois é onde será possível fazer acesso remoto, e recomendo que depois da instalação sempre desative o acesso remoto a VM, segue um exemplo de firewall com nftables que já é o padrão no Debian 11 substituindo o antigo iptables, no exemplo já irei proteger também a porta do SSH, lembre-se de deixar seus IPs na ACL de permissões.

# systemctl enable nftables

Modelo fechando as portas do SSH [22] e a range de acesso remoto [9000-9100], você pode personalizar de acordo com sua instalação.

# vim /etc/nftables.conf

#!/usr/sbin/nft -f
  
flush ruleset

table inet filter {
    # IPv4 que terao acesso 
    set acesso-total4 {
        type ipv4_addr
        flags interval
        elements = { 200.200.200.16/28, 200.200.200.0/28}
    }
    # IPv6 que terao acesso 
    set acesso-total6 {
        type ipv6_addr
        flags interval
        elements = { 2804:1234:bebe::48, 2804:4321:bebe::/48  }
    }
    chain input {
        type filter hook input priority 0;

        # Permite acesso SSH na porta 22
        ip saddr  @acesso-total4 tcp dport 22 counter accept
        ip6 saddr @acesso-total6 tcp dport 22 counter accept
        tcp dport 22 counter drop

        # Permite acesso tela remota portas padões Vbox
        ip saddr  @acesso-total4 tcp dport { 9000-9100 } counter accept
        ip6 saddr @acesso-total6 tcp dport { 9000-9100 } counter accept
        tcp dport { 9000-9100 } counter drop
        
        type filter hook input priority 0;
    }
    chain forward {
        type filter hook forward priority 0;
    }
    chain output {
        type filter hook output priority 0;
    }
}

Reinicie o nftables e verifique se o mesmo foi carregado:

# systemctl restart nftables
# nft list ruleset

Adicione o usuario vbox ao grupo, inicialize o servi web service e reinicie a máquina.

# usermod -a -G vboxusers vbox
# su - vbox --shell=/bin/bash -c 'vboxwebsrv &'
# reboot

Agora acesse:
https://DOMINIO/
Usuário: admin
Senha: admin

Não esqueça de alterar a senha do usuário admin!

O mais legal que você está usando quase nada do hardware da máquina para “subir” seu sistema de virtualização.

Virtulabox peca em não dar uma solução para inicialização automática, mas é muito fácil fazer isso incluindo no rc.local. Use o comando:

#  su - vbox --shell=/bin/bash -c 'VBoxManage list vms'

Vai ser listado os ID das suas VMs. Ex:
“DNS-SERVER” {d288884d-a3d4-4903-b84e-5c6039af13b5}
“ZABBIX-SERVER” {a2893475-atd4-4973-b81e-6039af13bss5}

Agora que você ja tem as IDs adicione em /etc/rc.local: da seguinte forma, alterando pelas suas ID.

sleep 30 #  sleep para aguardar 30seg para dar tempo do modulo do kernel ter tempo de iniciar
su - vbox --shell=/bin/bash -c 'VBoxHeadless -s d288884d-a3d4-4903-b84e-5c6039af13b5 &'
su - vbox --shell=/bin/bash -c 'VBoxHeadless -s a2893475-atd4-4973-b81e-6039af13bss5 &'

Agora quando o servidor reiniciar suas VMs vão iniciar automaticamente, (Não esqueça de quando for desligar o servidor fazer o processo de desligamento de cada VM)

Uma das vantagens deste servidor é que é o virtualbox é muito simples!!! Dentro de /home/vbox/ vão estar suas imagens sendo muito facil de fazer uma copia e migrada para algum outro servidor em caso de “pau”. É claro tenha sempre redundância de hardware em seu servidor, faça sempre pelo menos um RAID1 (espelhamento de disco) eu gosto de fazer RAID10 com pelo menos 5 SSDs, onde 1 dos SSDs eu instalo o sistema e os outros 4 (ou 6 ou 8 …) somo ex 2 (RAID0) e espelho nos outros 2 (RAID1) logo temos o RAID10.

Acesso remoto
No windows você pode usar o famoso mstsc e informar seu IP:PORTA, no linux tem um pacote chamado vinagre basta instala-lo.

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!

BÔNUS COMANDOS TERMINAL

# Listar todos os tipos de sistemas operacionais 
VBoxManage list ostypes

# Criar uma VM
VBoxManage createvm --name "Debian" --ostype Debian_64 --register

# Definir memória (RAM) e CPUs**:
VBoxManage modifyvm "Debian" --memory 2048
VBoxManage modifyvm "Debian" --cpus 4
VBoxManage modifyvm "Debian" --memory 2048 --cpus 4

# Criar um disco rígido virtual (VDI) de 80GB com controladora NVMe
# Primeiro, crie o disco:
VBoxManage createmedium disk --filename ~/VirtualBox\ VMs/Debian/DebianDisk.vdi --size 81920 --format VDI
# Em seguida, crie o controlador NVMe e anexe o disco a ele:
VBoxManage storagectl "Debian" --name "SATAController" --add sata --controller IntelAhci --portcount 1 --bootable on
VBoxManage storageattach "Debian" --storagectl "SATAController" --port 0 --device 0 --type hdd --medium ~/VirtualBox\ VMs/Debian/DebianDisk.vdi

# Configurar a placa de rede em modo bridge, utilizando eth0
VBoxManage modifyvm "Debian" --nic1 bridged --bridgeadapter1 eth0

# Adicionando mais interfaces
VBoxManage modifyvm "Debian" --nic2 bridged
VBoxManage modifyvm "Debian" --bridgeadapter2 eth0

# Desligar o áudio:
VBoxManage modifyvm "Debian" --audio none

# Define momoria de video:
VBoxManage modifyvm "Debian" --vram 16

# Alterar a controladora gráfica
VBoxManage modifyvm "Debian" --graphicscontroller vmsvga

# Listar VMS
VBoxManage list vms
"Debian" {941d837d-b357-4d19-bd06-b4a7750e321b}

# Iniciar VM
VBoxHeadless --startvm "Debian"
VBoxHeadless --startvm 9bee8518-37ab-492f-b8c5-4989e87bed9b

# Desligar VM
VBoxManage controlvm "Debian" acpipowerbutton
VBoxManage controlvm "Debian" poweroff

# Lista VMs ligadas
VBoxManage list runningvms

# Tirar um snapshot: 
VBoxManage snapshot "Debian" take "nome_snap"
VBoxManage snapshot "Debian" take `date +'%Y-%m-%d_%H-%M-%S'`

# Listar snapshots: 
VBoxManage snapshot "Debian" list
VBoxManage snapshot "941d837d-b357-4d19-bd06-b4a7750e321b" list 
   Name: 2024-02-14_09-54-25 (UUID: 23c1301a-7017-4763-aded-44516d9668b0)
      Name: 2024-02-14_09-54-59 (UUID: 70fc34e7-54dc-493f-af15-6b0858c1dadb)
         Name: 2024-02-14_09-55-09 (UUID: 19cf9f02-dc46-45fb-b22a-c133cfea9f78) *

# Restaurar um snapshot: 
VBoxManage snapshot "Debian" restore "nome_snap"
VBoxManage snapshot "Debian" restore "2024-02-14_09-54-25"

# Deletar um snapshot: 
VBoxManage snapshot "Debian" delete "nome_snap"
VBoxManage snapshot "Debian" delete "2024-02-14_09-54-59"

# Recuperando uma VM pelos arquivos (incluído os SNAPS, estrutura completa)
VBoxManage registervm ~/VirtualBox\ VMs/Debian.vbox

# Exportando (OVA)
VBoxManage export "Debian_12" -o /caminho/Debian_12.ova

# Mais comandos

# Exemplo bridged
VBoxManage modifyvm "RouterOS" --nic5 bridged
VBoxManage modifyvm "RouterOS" --bridgeadapter5 eth0

# Exemplo intnet
VBoxManage modifyvm "RouterOS" --nic5 intnet
VBoxManage modifyvm "RouterOS" --intnet5 "switch_lab"
VBoxManage modifyvm "RouterOS" --cableconnected5 on

# Modo Promíscuo
# deny: Não permite que a interface de rede opere em modo promíscuo.
# allow-vms: Permite que a interface de rede comunique com outras máquinas virtuais.
# allow-all: Permite que a interface de rede comunique com todas as máquinas virtuais e com 
VBoxManage modifyvm "RouterOS" --nicpromisc5 allow-all

# Definir o tipo de placa de rede para o quinto adaptador 
# Am79C970A: AMD PCNet PCI II (Am79C970A);
#  Am79C973: AMD PCNet FAST III (Am79C973, a opção padrão);
#   82540EM: Intel PRO/1000 MT Desktop (82540EM);
#   82543GC: Intel PRO/1000 T Server (82543GC);
#   82545EM: Intel PRO/1000 MT Server (82545EM);
#    virtio: Paravirtualized network adapter (virtio-net).

VBoxManage modifyvm "RouterOS" --nictype5 82543GC

# Definir um endereço MAC específico para o quinto adaptador
VBoxManage modifyvm "RouterOS" --macaddress5 0800000000A4

# Ver informações da VM por comando
VBoxManage showvminfo "RouterOS"
VBoxManage showvminfo "RouterOS" | grep "NIC" 

# Para adaptadores adicionais, substitua --nic5 por --nic6, --nic7, ou --nic8, conforme necessário. 

# Precisa mais que 8? Ativa 36 slot para interfaces.
VBoxManage modifyvm "RouterOS" --chipset ich9 --ioapic on

VBoxManage modifyvm "RouterOS" --nic9 intnet
VBoxManage modifyvm "RouterOS" --intnet9 "switch_amarelo"
VBoxManage modifyvm "RouterOS" --cableconnected9 on
VBoxManage modifyvm "RouterOS" --nictype9 82543GC
VBoxManage modifyvm "RouterOS" --macaddress9 0800000000B1

# Definir uma mac aleatório
VBoxManage modifyvm "RouterOS" --macaddress1 auto
VBoxManage modifyvm "RouterOS" --macaddress2 auto
VBoxManage modifyvm "RouterOS" --macaddress3 auto

O post Servidor de virtualização Web com Debian 11 bullseye + Virtualbox 7.0 apareceu primeiro em Remontti.

Distribuição utilizada neste tutorial:
Debian 11 (Bullseye) 64 bits instalação mínima
Como melhorar a produtividade no seu Debian após instalação (Recomendado)

Atualize e instale os pacotes necessários

# apt update -y 
# apt upgrade -y 
# apt install vim wget apache2 mariadb-server php libapache2-mod-php php-mysql lsb-release gnupg2 sudo -y

Adicione o repositório do Zoneminder

# echo "deb https://zmrepo.zoneminder.com/debian/release-1.36 "`lsb_release -c -s`"/" > /etc/apt/sources.list.d/zoneminder.list
# wget -O - https://zmrepo.zoneminder.com/debian/archive-keyring.gpg | apt-key add -
# apt update

Instalação

# apt install zoneminder

Ajustando o timezone do PHP

# sed -i "s/;date.timezone =/date.timezone = $(sed 's/\//\\\//' /etc/timezone)/g" /etc/php/7.4/apache2/php.ini

Habilitaremos as configurações do zoneminder para o apache bem como ativar alguns mods.

# a2enconf zoneminder
# a2enmod rewrite headers expires cgi

Reinicie o apache

# systemctl restart apache2

Crie um banco de dados para o zoneminder

# mariadb -u root

Altere ALTERE_3ST4_SENHA para sua senha.

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

Altere em /etc/zm/zm.conf ZM_DB_USER e ZM_DB_PASS para os calores criados.

# vim /etc/zm/zm.conf

ZM_DB_USER=zm
ZM_DB_PASS=ALTERE_3ST4_SENHA

Habilite o zoneminder para iniciar no boot e start o mesmo.

# systemctl enable zoneminder
# systemctl start zoneminder

Por segurança recomendo definir uma senha para o root do mariaDB
Para aumentar a seguraçã vamos definir uma senha para o usuário root do MariDB, não esqueça de alterar ALTERE_3ST4_SENHA pela sua senha.

# mariadb -u root

USE mysql;
ALTER USER 'root'@'localhost' IDENTIFIED BY 'ALTERE_3ST4_SENHA';
FLUSH PRIVILEGES;
EXIT;

Apague seus rastros, em /root/.mysql_history temos um histórico com todos os comandos dado no terminal do MariaDB, então não é legal deixar lá em texto puro a senha!

# > /root/.mysql_history

Abra o Zoneminder em seu navegador acessando http://___IP___/zm

Clique em APPLY

Para alterar para Portugues acesse o menu Options localize LANG_DEFAULT e altere para pt_br e clique em SAVE. Recarregue a pagina para atualiza.

Para mais ajuda acesse: Guia do Usuário

FONTES:
https://zoneminder.readthedocs.org/
https://wiki.zoneminder.com/Debian_11_Bullseye_with_Zoneminder_1.36.x
https://github.com/ZoneMinder/ZoneMinder
RECOMENDADO:
https://github.com/pliablepixels/zmeventnotification
https://github.com/pliablepixels/zmMagik
https://github.com/manupap1/libzoneminder-plugin-openalpr

O post Sistema de software de vigilância por vídeo de código aberto: ZoneMinder apareceu primeiro em Remontti.

Gerenciar todos os seus processos empresariais
– Editor de documentos
– Gerenciador de projetos.
– Painel CRM
– Cliente de e-mail
– Lista de contatos
– Agenda

Neste tutorial irei ensinar instalar a versão Community (faça você mesmo), existe várias forma de instalação, mas como somos os cara do Debian bora lá montar nosso servidor!

Requisitos mínimos de sistema:
– CPU dual core 2 GHz
– RAM 6 GB
– 6 GB SWAP
– HDD 40 GB
– OS amd64

Distribuição utilizada neste tutorial:
Debian 11 (Bullseye) 64 bits instalação mínima
Como melhorar a produtividade no seu Debian após instalação (Recomendado)

# apt install wget
# wget https://download.onlyoffice.com/install/workspace-install.sh

Temos varias opções de instalação, execute o script com parâmetro -h para conhece-las.

# bash workspace-install.sh -h

Vou deixar aqui duas opções que serão provavelmente a de sua escolha:

Instale todos os componentes da solução:

Configurando um domínio para o serviço de e-mail

No Debian necessitamos habilitar o vsyscall que vem desabilitado no kernel, o vsyscall é um mecanismo que é usado para acelerar certas chamadas de sistema e necessário para que ONLYOFFICE Mail funcione corretamente. OBS: Para instalação em contêiner do ONLYOFFICE.
Para verificar se vsyscall esta ativo execute o comando:

# cat /proc/self/maps | egrep 'vdso|vsyscall'

Se o resultado for o a baixo será necessário ativar ele.

7fffa9dd3000-7fffa9dd5000 r-xp 00000000 00:00 0             [vdso]

# nano /etc/default/grub

Altere:

GRUB_CMDLINE_LINUX_DEFAULT="quiet"

Por:

GRUB_CMDLINE_LINUX_DEFAULT="quiet vsyscall=emulate"

Atualize o grub e reinicie

# update-grub
# reboot

Agora ao executar o comando, o retorno será:

# cat /proc/self/maps | egrep 'vdso|vsyscall'
7ffe7f381000-7ffe7f383000 r-xp 00000000 00:00 0                [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0        [vsyscall]

Vamos a instalação, informando seu domínio utilizando o parâmetro -md. (ou pule para o próximo comando para não instalar o servidor de e-mail)

# bash workspace-install.sh -md onlyoffice.remontti.com.br

Sem servidor de e-mail

# bash workspace-install.sh -ims false

Com sua escolha, agora ao executar o script será lhe solicitados o forma de instalação: Install with Docker [Y/N/C]?
– Y Irá instalar o Onlyoffice usando docker. (Recomendado)
– N Irá instalar o Onlyoffice usando pacotes deb.
– C Cancelar.

Irei utilizar opção recomendada pela Onlyoffice, com docker [Y], se você é mais ninja e quer ter total gerencia de forma direta pode fazer a instalação pelos pacotes debian utilizando opção [N].

A instalação ira levar alguns minutos… (Depende do seu hardware e velocidade da conexão)

Ao finalizar podemos verificar quais as portas foram abertas com o comando:

# ss -putan | grep LIST

tcp   LISTEN 0      4096           0.0.0.0:4190         0.0.0.0:*     users:(("docker-proxy",pid=7370,fd=4))             
tcp   LISTEN 0      4096           0.0.0.0:993          0.0.0.0:*     users:(("docker-proxy",pid=7417,fd=4))             
tcp   LISTEN 0      4096           0.0.0.0:995          0.0.0.0:*     users:(("docker-proxy",pid=7393,fd=4))             
tcp   LISTEN 0      4096           0.0.0.0:5222         0.0.0.0:*     users:(("docker-proxy",pid=15682,fd=4))            
tcp   LISTEN 0      4096           0.0.0.0:587          0.0.0.0:*     users:(("docker-proxy",pid=7439,fd=4))             
tcp   LISTEN 0      4096           0.0.0.0:143          0.0.0.0:*     users:(("docker-proxy",pid=7483,fd=4))             
tcp   LISTEN 0      4096           0.0.0.0:80           0.0.0.0:*     users:(("docker-proxy",pid=15724,fd=4))            
tcp   LISTEN 0      4096           0.0.0.0:465          0.0.0.0:*     users:(("docker-proxy",pid=7462,fd=4))             
tcp   LISTEN 0      128            0.0.0.0:22           0.0.0.0:*     users:(("sshd",pid=407,fd=3))                      
tcp   LISTEN 0      4096           0.0.0.0:25           0.0.0.0:*     users:(("docker-proxy",pid=7504,fd=4))             
tcp   LISTEN 0      4096           0.0.0.0:443          0.0.0.0:*     users:(("docker-proxy",pid=15704,fd=4))            
tcp   LISTEN 0      4096              [::]:4190            [::]:*     users:(("docker-proxy",pid=7380,fd=4))             
tcp   LISTEN 0      4096              [::]:993             [::]:*     users:(("docker-proxy",pid=7425,fd=4))             
tcp   LISTEN 0      4096              [::]:995             [::]:*     users:(("docker-proxy",pid=7401,fd=4))             
tcp   LISTEN 0      4096              [::]:5222            [::]:*     users:(("docker-proxy",pid=15690,fd=4))            
tcp   LISTEN 0      4096              [::]:587             [::]:*     users:(("docker-proxy",pid=7446,fd=4))             
tcp   LISTEN 0      4096              [::]:143             [::]:*     users:(("docker-proxy",pid=7489,fd=4))             
tcp   LISTEN 0      4096              [::]:80              [::]:*     users:(("docker-proxy",pid=15731,fd=4))            
tcp   LISTEN 0      4096              [::]:465             [::]:*     users:(("docker-proxy",pid=7468,fd=4))             
tcp   LISTEN 0      128               [::]:22              [::]:*     users:(("sshd",pid=407,fd=4))                      
tcp   LISTEN 0      4096              [::]:25              [::]:*     users:(("docker-proxy",pid=7511,fd=4))             
tcp   LISTEN 0      4096              [::]:443             [::]:*     users:(("docker-proxy",pid=15712,fd=4))

Podemos verificas os containers dockers:

# docker ps -a -s

CONTAINER ID   IMAGE             COMMAND                  PORTS                        SIZE

779b13c4376b   communityserver   "/app/run-community-…"   0.0.0.0:80->80/tcp,          76MB (virtual 4.54GB)
                                                          :::80->80/tcp, 
                                                          0.0.0.0:443->443/tcp, 
                                                          :::443->443/tcp, 
                                                          3306/tcp, 
                                                          5280/tcp, 
                                                          9865-9866/tcp, 
                                                          9871/tcp, 
                                                          9882/tcp, 
                                                          0.0.0.0:5222->5222/tcp, 
                                                          :::5222->5222/tcp, 
                                                          9888/tcp

6e408504e7b0   controlpanel      "/var/www/onlyoffice…"   80/tcp, 443/tcp              909kB (virtual 520MB)

3beaea4df31e   mailserver        "/bin/sh -c 'export …"   0.0.0.0:25->25/tcp,          3.3MB (virtual 1.9GB)
                                                          :::25->25/tcp, 
                                                          0.0.0.0:143->143/tcp, 
                                                          :::143->143/tcp, 
                                                          0.0.0.0:465->465/tcp, 
                                                          :::465->465/tcp, 
                                                          0.0.0.0:587->587/tcp, 
                                                          :::587->587/tcp, 
                                                          0.0.0.0:993->993/tcp, 
                                                          :::993->993/tcp, 
                                                          0.0.0.0:995->995/tcp, 
                                                          :::995->995/tcp, 
                                                          3306/tcp, 
                                                          0.0.0.0:4190->4190/tcp, 
                                                          :::4190->4190/tcp, 
                                                          8081/tcp
9cf6e70c156f   documentserver    "/app/ds/run-documen…"   80/tcp, 443/tcp              498MB (virtual 3.43GB

a33ae4057009   elasticsearch     "/tini -- /usr/local…"   9200/tcp, 9300/tcp           149kB (virtual 812MB)

ba2fd3132277   mysql             "docker-entrypoint.s…"   3306/tcp, 33060/tcp          6B (virtual 524MB)

Acesse seu domínio em seu navegado (ou endereço IP), ao acessar pela primeira vez será feito o cadastro do administrador.

Plataforma instalada com sucesso!

Para convidar outros usuários a plataforma basta acessar as Configurações e clicar em: Convidar usuário para o portal, e enviar o link para ele.

Um e-mail será enviado para você também de confirmação, e após outro com algumas instruções.

As principais configurações são feitas em Control Panel

Que tal conectar ao “nosso nextcloud“?

Te muita coisa mas muita coisa, que se fosse escrever um tutorial levaria dias. A central de ajuda é muito completa, tem muito material na documentação, então não vou ficar criando novamente a roda

Meu objetivo era apresentar o projeto e realizar a instalação do mesmo. Espero que tenha gostado!

E não esqueça de realizar atualizações executando o script:

# bash workspace-install.sh -u true

Se quiser apoiar o blog e 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://helpcenter.onlyoffice.com

O post ONLYOFFICE Workspace – A suíte office mais completa e poderosa open source apareceu primeiro em Remontti.

O Cockpit permite que os administradores de sistema executem facilmente tarefas como iniciar contêineres, virtualização, administração de armazenamento, configuração de rede, inspeção de logs e assim por diante.

Distribuição utilizada neste tutorial:
Debian 11 (Bullseye) 64 bits instalação mínima
Como melhorar a produtividade no seu Debian após instalação (Recomendado)

Ativando repositório Backports

Usarei o repositório backports para obter os pacotes mais recentes do Cockpit (tem mais recursos)

# . /etc/os-release 
# echo "deb http://deb.debian.org/debian ${VERSION_CODENAME}-backports main" > /etc/apt/sources.list.d/backports.list
# apt update

Instalação Cockpit

Iremos instalar o cockpit com algumas “extensões” básicas.

# apt install -t ${VERSION_CODENAME}-backports cockpit \
 cockpit-storaged cockpit-networkmanager cockpit-packagekit cockpit-doc lm-sensors 

Cockpit é executado utilizando a porta 9090, para verificar se a mesta esta aberta execute:

# ss -pnltu | grep 9090

Abra em seu navegador http://HOST:9090/

Entre com usuário e senha do sistema operacional. Todos usuários irão logar, sistemas como Ubuntu você pode entrar com seu usuário comum e solicitar permissões, mas neste caso como é um debian entrarei diretamente com root.

Umas das coisar que não gosto que durante a instalação do cockpit ganhamos um brinde um serviço de e-mail exim4, como nõ tenho menos interesse em ter ele rodando irei desativa-lo.

# systemctl stop exim4 
# systemctl disable exim4

Gerenciando Máquinas virtuais

Que tal subir VMs sem um sistema como VMware, Proxmox, Xen, Virtualbox, entre outros?
– libvirt-dbus para enumerar máquinas, obter notificações de atualização de status e operações como iniciar/parar/excluir
– virt-install e virt-xml para criar e modificar definições de máquina; ambos fazem parte do projeto virt-manager
Instale os pacotes:

# . /etc/os-release
# apt install -t ${VERSION_CODENAME}-backports cockpit-machines \
 libvirt-daemon-driver-storage-gluster libvirt-daemon-driver-storage-iscsi-direct \
 libvirt-daemon-driver-storage-rbd libvirt-daemon-driver-storage-zfs libvirt-login-shell

A imagens (discos) das VMs ficam em /var/lib/libvirt/images

Gerenciando Containers

Ativa no Cockpit interface para containers Podman que é uma ferramenta multiplataforma de linha de comando, Open-Source que permite criar e gerenciar imagens de contêiner diretamente.

Um dos maiores diferenciais do Podman é que ele não precisa de um serviço (daemon-less) rodando em background para funcionar, e é totalmente Gratuito e Open-Source. É uma alternativa amigável para quem já esta acostumado com Docker, já que é baseado na CLI do Docker, tendo compatibilidade com as imagens Docker e suportando tambem Dockerfile’s e sendo possível ate rodar docker-compose.yml com podman-compose.

Instale o pacote cockpit-podman

# . /etc/os-release
# apt install -t ${VERSION_CODENAME}-backports cockpit-podman

Por segurança recomendo você aplicar um firewall com nftables (Já instalado no Debain 11) protegendo a porta 9090 apenas para sua rede local.

Gostou? Se quiser apoiar o blog e 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://cockpit-project.org/
https://github.com/cockpit-project/cockpithttps://github.com/cockpit-project/cockpit-machines
https://github.com/cockpit-project/cockpit-podman

O post Conheça o Cockpit, uma poderosa ferramenta para administração de servidores através do seu navegador. apareceu primeiro em Remontti.

O que é o Nginx Proxy Manager?
É um sistema que possui uma interface web limpa, eficiente e fácil de configurar, sem precisar saber muito sobre Nginx ou Letsencrypt.

Característica
– Interface de administração bonita e segura baseada
– Crie facilmente domínios de encaminhamento, redirecionamentos, streams e hosts 404 sem saber nada sobre Nginx
– SSL grátis usando Let’s Encrypt ou forneça seus próprios certificados SSL personalizados
– Listas de acesso e autenticação HTTP básica para seus hosts
– Configuração avançada do Nginx disponível para superusuários
– Gerenciamento de usuários, permissões e log de auditoria

Distribuição testadas:
Debian 12 Bookworm
Debian 11 Bullseye

Como melhorar a produtividade no seu Debian após instalação (Recomendado)

Porta Utilizadas
81 – Porta de administração do Nginx Proxy Manager
80 – Porta HTTP pública
443 – Porta HTTP pública

Configurações de interface de Rede

Para a configuração da interface de rede vou usar uma configuração Pointopoint (Ponto a ponto) assim utilizando de apenas um endereço IP público, você pode (deve) ler este tutorial para conhecer varias possibilidades de configuração de rede pensa em como economizar endereços IPs.

# vim /etc/network/interfaces

No meu exemplo vamos pesar que esse servidor esteja conectado ao RouterOS/Mikrotik ether2 e meu endereço de IP publico será o 200.200.200.255

allow-hotplug enp0s3
iface enp0s3 inet static
        address 200.200.200.255
        pointopoint 192.168.171.171
        netmask 255.255.255.255
        gateway 192.168.171.171

Agora no seu RouterOS vamos criar nosso Pointopoint gatewai 192.168.171.171 tendo como network o endereço IP público.

RouterOS# /ip address
RouterOS# add address=192.168.171.171 comment=Pointopoint interface=ether2 network=200.200.200.255

Se você não tem IP publico para colocar em seu servidor, então fixe um endereço IP Privado e redirecione as potas 80,81 e 443 para ele, utilizando seu IP público que está em seu router. Exemplo:

allow-hotplug enp0s3
iface enp0s3 inet static
        address 10.10.10.2/24
        gateway 10.10.10.1

E é clario se você conter endereço IPv6, não deixe de configurar sua placa! Exemplo:

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

Instalação Docker

Iremos instalar os pacotes necessários, bem como adicionar o repositório oficial do Docker

# apt install ca-certificates curl gnupg2 apt-transport-https lsb-release
# curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
# echo "deb https://download.docker.com/linux/debian $(lsb_release -cs) stable" > /etc/apt/sources.list.d/docker.list

Atualize o repositório e instale-o

# apt update
# apt install docker-ce docker-ce-cli containerd.io

Instalação Docker Compose

Vamos fazer download do Docker Compose, e adicionar aos binários do nosso servidor como um executável.

# curl -L "https://github.com/docker/compose/releases/download/v2.24.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
# chmod +x /usr/local/bin/docker-compose
# ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

Versão baixada foi a 2.24.5, mas você pode consultar uma mais recente em: https://github.com/docker/compose/releases/, para verificar qual versão instalado use:

# docker-compose --version

Docker Compose version v2.24.5

Instação Nginx Proxy Manager

Crie os diretórios quais ficarão todas as configurações:

# mkdir /etc/nginx-proxy
# mkdir /etc/nginx-proxy/{data,letsencrypt}

Crie seu arquivo de composição do Docker com as configuração, para realizar a instalação dos containers do Nginx Proxy Manager e MariaDB com o Docker Compose. (Ajustes as senhas)

# vim /etc/nginx-proxy/docker-compose.yml

Adicione:

version: "3"
services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      # These ports are in format <host-port>:<container-port>
      - '80:80'       # Porta HTTP pública
      - '443:443'     # Porta HTTPS pública
      - '81:81' # Porta de administracao do Nginx Proxy
      # Adicione qualquer outra porta Stream que você queira expor, ex
      # - '21:21' # FTP
    environment:
      DB_MYSQL_HOST: "db"
      DB_MYSQL_PORT: 3306
      DB_MYSQL_USER: "nginxproxy"
      DB_MYSQL_PASSWORD: "S3NHA_NGINX_PR0XY"
      DB_MYSQL_NAME: "nginxproxy"
      # Remova o comentário se você não tem o IPv6 em seu host
      # DISABLE_IPV6: 'true'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    depends_on:
      - db

  db:
    image: 'jc21/mariadb-aria:latest'
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: 'S3NHA_D3_R00T'
      MYSQL_DATABASE: 'nginxproxy'
      MYSQL_USER: 'nginxproxy'
      MYSQL_PASSWORD: 'S3NHA_NGINX_PR0XY'
    volumes:
      - ./mysql:/var/lib/mysql

Execute o comando Docker Compose

# cd /etc/nginx-proxy
# docker-compose up -d

Aguarde finalizar… em seguida visualize se os containers que foram criados

# docker ps -a

CONTAINER ID   IMAGE                             COMMAND             CREATED          STATUS         PORTS                                                                                  NAMES
6b796a07af22   jc21/nginx-proxy-manager:latest   "/init"             9 seconds ago    Up 7 seconds   0.0.0.0:80-81->80-81/tcp, :::80-81->80-81/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   nginx-proxy-app-1
4c93d3b8a544   jc21/mariadb-aria:latest          "/scripts/run.sh"   13 seconds ago   Up 8 seconds   3306/tcp                                                                               nginx-proxy-db-1

Abra em navegador http://IP_SERVIDOR/ se tudo ocorreu bem você verá:

Agora abra na porta 81 http://IP_SERVIDOR:81/ e entre com:

Email: admin@example.com 
Password: changeme

Ao entrar pela primeira vez um formulário com informações será exibido para você alterar seus dados, altere seus e-mail e senha.

Configurações de DNS Autoritativa

Para que possamos encaminhar os acessos iremos necessitar configurar um subdomínios para cada situação em nosso servidor DNS autoritativo.

Vamos criar um cenário fictício para ilustrar melhor. Temos 1 clientes recebendo IPs privados da classe de um CGNAT, e o mesmo solicita um redirecionamento de portas para seu DVR. O cliente recebe o endereço IP privado 100.64.0.71 (Fixado) seu DVR esta na porta 80 na rede local 192.168.0.7. Para cada situação irei criar um novo subdomínio, exemplo “dvrudi” no servidor DNS autoritativo apontando para o IP Público do seu servidor Nginx Proxy, assim eu acesso “dvrudi.remontti.com.br”. Agora ao acessar o roteato e criar o redirecionamento provavelmente não iremos poder usar a porta 80, pois ela já é a porta de acesso do roteador 100.64.0.71, e é bem possível que você tenha fechado ela em seu firewall também para se proteger de ataques, neste caso use outra porta exemplos 60080 para fazer o direcionamento para a porta 80 do DVR, o cliente nem precisa saber desta porta 60080 ela é a penas a porta de entrada do Nginx Proxy. Agora volte ao Admin do NPM, no menu Hosts >> Proxy Hosts >> Add Proxy Host

Se desejar pode ativar certificado grátis com Lets Encrypt.

Agora ao acessar “dvrudi.remontti.com.br” ele estará acessando diretamente o DVR. #clientefeliz

Legal não? Agora você pode ter um painel administrativo para redirecionamento de serviços web, no exemplo sitei o caso de CGNAT, mas você pode usar para qualquer outra situação, bem como até apontar para um subdiretório, e restringir o acesso do mesmo, sabe esses ERP porco que você acessar com /admin, daria para restringir. Bom o painel do NPM é bem intuitivo, para quem já conhece o Nginx sabe das suas enumeras possibilidades vai achar um doce.

Atualizando do NPM

# cd /etc/nginx-proxy/
# docker-compose down
# docker-compose pull
# docker-compose up -d

Gostou? Se quiser apoiar o blog e 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://nginxproxymanager.com/guide/
https://github.com/NginxProxyManager/nginx-proxy-manager

O post Instalação do Nginx Proxy Manager apareceu primeiro em Remontti.

O Zabbix é uma solução de nível enterprise, de código aberto. O Zabbix é um software que monitora vários parâmetros da rede, dos servidores e da saúde dos serviços. Utiliza-se de um mecanismo flexível de notificação que permite configurar alertas por e-mail entre outros como Telegram, para praticamente qualquer evento. As notificações permitem que se reaja rapidamente à problemas no ambiente. O Zabbix oferece excelentes recursos de relatórios e visualização de dados armazenados. Isso faz com que o Zabbix seja a ferramenta ideal para planejamento de capacidade.

Requisitos Debian 11 Bullseye

– Instalação do Debian 11 Bullseye limpa passo-a-passo
– Servidor WEB NGINX + PHP + PostgreSQL + phpPgAdmin + Letsencrypt no Debian 11 Bullseye (LNPP)

Instalação do Zabbix 6

Para instalação do Zabbix vamos incluir o repositório do oficial do Zabbix.

# su -
# cd /tmp
# apt install wget

Repositório Debian 11

# cd /tmp/
# wget https://repo.zabbix.com/zabbix/6.0/debian/pool/main/z/zabbix-release/zabbix-release_6.0-4+debian11_all.deb
# apt install ./zabbix-release_6.0-4+debian11_all.deb
# apt update; apt upgrade -y

# apt install zabbix-server-pgsql zabbix-frontend-php php-pgsql zabbix-nginx-conf zabbix-sql-scripts zabbix-agent

Vamos criar uma base de dados chamada zabbix e um usuário também chamado de zabbix no PostgreSQL.
Não esqueça de alterar a senha: Use o gerador de senha: https://senhasegura.remontti.com.br/

# su - postgres
$ createuser --pwprompt zabbix
Digite a senha para a nova role:  <SENHA ZABBIX>
Digite-a novamente: <SENHA ZABBIX>
Senha: <SENHA POSTGRES CASO TENHA DEFINIDO NA INSTALAÇÃO DO MESMO>

$ createdb -O zabbix zabbix
Senha: <SENHA POSTGRES>

Importe o esquema inicial e os dados. Você será solicitado a inserir a senha que foi criada anteriormente.

$ zcat /usr/share/zabbix-sql-scripts/postgresql/server.sql.gz | psql -U zabbix -d zabbix &>/dev/null
Senha para usuário zabbix: : <SENHA ZABBIX>
$ exit

Edite o arquivo zabbix_server.conf para informar os dados para conexão com do PostgreSQL.

# vim /etc/zabbix/zabbix_server.conf

Procure por # DBPassword= descomente e sete sua senha.

#...
DBPassword=<SENHA ZABBIX>
#...

Ajuste o arquivo /etc/zabbix/php-fpm.conf, descomente e defina o fuso horário correto. timezone Sua região.

# vim /etc/zabbix/php-fpm.conf

Adicione:

php_value[date.timezone] = America/Sao_Paulo

Ajuste as configurações do nginx.

# vim /etc/nginx/conf.d/zabbix.conf 

Deixei algumas linhas comentadas como exemplo, faça de acordo com sua necessidade.

server {
        listen 80;
        listen [::]:80;
        server_name    zabbix.remontti.com.br localhost;
        #server_name   OU_SEU_IP;

        # Metodo simples para quem quer rodar em uma determinada porta
        #listen 8181;
        #listen [::]:8181;
        #server_name     _;

        root    /usr/share/zabbix;
        index   index.php;

        # Desmomente para deixar restringido apenas para determinados prefixos
        #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 100M;
 
        location = /favicon.ico {
                log_not_found   off;
        }

        location / {
                try_files       $uri $uri/ =404;
        }

        location /assets {
                access_log      off;
                expires         10d;
        }

        location ~ /\.ht {
                deny            all;
        }

        location ~ /(api\/|conf[^\.]|include|locale) {
                deny            all;
                return          404;
        }

        location ~ [^/]\.php(/|$) {
                fastcgi_pass    unix:/var/run/php/zabbix.sock;
                fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_index   index.php;

                fastcgi_param   DOCUMENT_ROOT   /usr/share/zabbix;
                fastcgi_param   SCRIPT_FILENAME /usr/share/zabbix$fastcgi_script_name;
                fastcgi_param   PATH_TRANSLATED /usr/share/zabbix$fastcgi_script_name;

                include fastcgi_params;
                fastcgi_param   QUERY_STRING    $query_string;
                fastcgi_param   REQUEST_METHOD  $request_method;
                fastcgi_param   CONTENT_TYPE    $content_type;
                fastcgi_param   CONTENT_LENGTH  $content_length;

                fastcgi_intercept_errors        on;
                fastcgi_ignore_client_abort     off;
                fastcgi_connect_timeout         60;
                fastcgi_send_timeout            180;
                fastcgi_read_timeout            180;
                fastcgi_buffer_size             128k;
                fastcgi_buffers                 4 256k;
                fastcgi_busy_buffers_size       256k;
                fastcgi_temp_file_write_size    256k;
        }
}

Inicie o servidor Zabbix e os processos do agente e configure-os para que sejam iniciados durante o boot do sistema.

# systemctl enable zabbix-server zabbix-agent

Debian 11

# vim /etc/php/7.4/fpm/php.ini

Localize max_execution_time e altere de 30 para 600

max_execution_time = 600

# systemctl restart zabbix-server zabbix-agent nginx php7.4-fpm

Acesse em seu navegador http://seu_ip:porta ou http://zabbix.seudominio.com.br

Selecione o Edioma, e Próximo passo

Se tudo estiver ok: Próximo passo

Selecione PostgreSQL e informe a senha do usuário zabbix criada anteriormente, clique em Próximo passo.

Defina um nome, e selecione o Tema padrão e clique em Próximo passo

Se tudo estiver ok, Próximo passo

Fim

Entre com Usuário Admin e senha zabbix

Simples né? Gostou e 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.

Abraço!

Fontes:
https://www.zabbix.com/documentation/

O post Instalação do Zabbix 6 LTS + NGINX + PostgreSQL + Debian 11 Bullseye apareceu primeiro em Remontti.

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

#
#
#
#
#
#
#
#

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

Vamos utilizar o FastNetMon (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.

<NE-SEUMADRUGA> 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: 
<blockquote class="wp-embedded-content" data-secret="ghCHMDUZME"><a href="https://fastnetmon.com/fastnetmon-advanced/">FastNetMon Advanced</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; clip: rect(1px, 1px, 1px, 1px);" title="“FastNetMon Advanced” — FastNetMon DDoS Detection Tool" src="https://fastnetmon.com/fastnetmon-advanced/embed/#?secret=9HRlASbAu2#?secret=ghCHMDUZME" data-secret="ghCHMDUZME" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
You could order free one-month trial for Advanced edition here: 
<blockquote class="wp-embedded-content" data-secret="zdVTqp3qpj"><a href="https://fastnetmon.com/trial/">Order trial</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; clip: rect(1px, 1px, 1px, 1px);" title="“Order trial” — FastNetMon DDoS Detection Tool" src="https://fastnetmon.com/trial/embed/#?secret=kKLHfdm2fM#?secret=zdVTqp3qpj" data-secret="zdVTqp3qpj" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>

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:

<NE-SEUMADRUGA> 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

<NE-SEUMADRUGA> 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: <code>$1</code>" "<code>->></code> 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: <code>$1</code> $TIPO <b>[$3 pps]</b>" "<code>->></code> 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" "<code>FastNetMon: IP $1 blocked because $2 attack with power $3 pps</code>"
  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: <code>$1</code>" "<code>->></code> 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: <code>$1</code> $TIPO <b>[$3 pps]</b>" "<code>->></code> 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" "<code>FastNetMon: IP $1 blocked because $2 attack with power $3 pps</code>"
  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.

• Você necessita de acessar remotamente ativos dentro da empresa em que trabalha?
• Costuma deixar seus ativos acessíveis publicamente só para conectar de qualquer lugar?
• Você restringe esse acesso por pessoas e/ou grupos?
• Quando alguém com privilégios é demitido. Você tem que ir em diversos sistemas e equipamentos rapidamente, para remover os acessos?
• Você sente falta de um local centralizado e único, que contenha a definição de seus sistemas para trabalhar remotamente?

Se a resposta para essas perguntas foi um “SIM”, então esse artigo pode lhe ajudar a melhorar a forma como você acessa determinados ativos em sua rede.

Primeiramente vamos a um conceito que muitos acham que VPN (Virtual Private Network) é a forma mais segura de acessar uma Intranet e assim prestar suporte remotamente de qualquer lugar. Bem, não queria destruir seu conceito mas; a VPN sem determinados cuidados com o seu sistema pessoal, de nada vai te proteger de um incidente que possa parar sua empresa. Imagine uma situação em que você esteja conectado remotamente via VPN corporativa, acessando um compartilhamento de arquivos da empresa e em algum momento durante o trabalho você adquiriu um bem sucedido ransomware. Esse malware causará grande prejuízo para a empresa e para a sua reputação, mesmo estando usando a tal VPN.

Outros preferem usar recursos como os Jump Servers. Equipamentos com sistemas, por exemplo Windows, rodando serviços como RDP (Remote Desktop Protocol), ou Anydesk, ou Teamviewer, ou qualquer outro equivalente para permitir o acesso local e a partir dele conectar em outros sistemas dentro da empresa. Nada contra o sistema da Microsoft ou qualquer produto citado mas não me sinto confortável em deixá-los públicos na Internet. Lembrando que não existem sistemas 100% seguros. Em algum momento falhas podem surgir e alguém pode explorá-las. Pense em uma vulnerabilidade Zero Day.

Então o que venho sugerir nesse artigo é que juntem as duas soluções VPN e Jump Server mas de uma maneira, que na minha opinião, seria mais segura que ambas as soluções acima, construídas isoladamente.

Continuem usando a VPN mas também pensando na segurança dos sistemas pessoais de quem utiliza a VPN, para trabalhar remotamente. Não usem VPN PPTP em suas soluções corporativas, é insegura, obsoleta e não funciona bem com CGNAT, em sistemas que não possuem suporte ao ALG (Application Layer Gateway) PPTP.

Ao invés de deixarem públicos seus Jump Servers, mantenha-os com IPs privados RFC1918 e acessíveis somente através da VPN. Assim chegaremos a dois níveis de autenticação pelo menos. Crie um ou mais servidores Jump e crie ACLs nos equipamentos e sistemas que só permitam acesso dos IPs privados dos Jump Servers.

Dessa forma vai conseguir resolver boa parte daquelas perguntas que fiz, mas ainda não é o objetivo principal deste artigo. Esse artigo vai focar na ferramenta Apache Guacamole que é uma aplicação para construirmos um Jump Server mais inteligente e seguro.

Mas o que seria o Apache Guacamole? Ele é um clientless remote desktop gateway, ou seja, você não precisa de um programa cliente instalado no seu desktop de trabalho ou pessoal, para acessar sistemas que usem os protocolos: RDP, VNC e SSH. Isso é feito através de um browser apenas e usando HTML5.

O Guacamole é uma aplicação Java que roda embaixo do Apache Tomcat. É dividido em duas partes, o server e os clients que fazem a conexão propriamente dita usando RDP, VNC ou SSH, de acordo com o tipo de acesso. Possui suporte a diversas bases de dados como MySQL, MariaDB, PostgreSQL e também LDAP.

Sua arquitetura funciona assim:

Requisitos para o nosso artigo

Debian 11 (Bullseye) 64 bits. Instalação mínima. Sistema deve restringir o acesso apenas via VPN e/ou Rede de Gerência da empresa (utilize regras de firewall iptables ou nftables para essa tarefa).
– VM com 2 cores ou mais. Dependerá da quantidade de acessos simultâneos.
– 2Gb de ram. Sugiro 4Gb.
– 10G de disco. Dependerá do crescimento da base de dados, se for local.
– Interface de rede com IP privado e liberado para acesso aos sistemas remotos.

:: Instalação do MariaDB 10.5 ::

# apt install mariadb-server mariadb-client 

Por padrão o pacote MariaDB no Debian usa unix_socket para autenticar o login do usuário, o que basicamente significa que você pode usar o nome de usuário e a senha do sistema operacional para efetuar login no console do MariaDB.
Assim, você pode logar diretamente sem fornecer a senha root do MariaDB, para aumentar a seguraça vamos definir uma senha para o usuário root do MariaDB, não esqueça de alterar ALTERE_3ST4_SENHA pela sua senha.

# mariadb -u root

USE mysql;
ALTER USER 'root'@'localhost' IDENTIFIED BY 'ALTERE_3ST4_SENHA';

Ainda logado no MariaDB vamos criar nossa base de dados para o Guacamole, não esqueça de alterar S3NHA_GUACAMOL3_US3R por sua senha.

CREATE DATABASE guacamole;
CREATE USER 'guacamole'@'localhost' IDENTIFIED BY 'S3NHA_GUACAMOL3_US3R';
GRANT ALL PRIVILEGES ON guacamole.* TO 'guacamole'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Apague seus rastros, em /root/.mysql_history temos um histórico com todos os comandos dado no terminal do MariaDB, então não é legal deixar lá em texto puro a senha que setamos!

# > /root/.mysql_history

:: Instalação Java JDK ::

# apt install openjdk-11-jdk libmariadb-java

Precisaremos configurar a variável de ambiente JAVA_HOME. No final do arquivo /etc/environment adicione o seguinte parâmetro JAVA_HOME=”/usr/lib/jvm/java-11-openjdk-amd64″

echo 'JAVA_HOME="/usr/lib/jvm/java-11-openjdk-amd64"' >>  /etc/environment

Em seguida carregamos o /etc/environment:

# source /etc/environment

:: Instalação Tomcat::

# apt install tomcat9 tomcat9-admin tomcat9-docs tomcat9-examples tomcat9-user

Feito isso vamos criar um usuário de acesso ao Tomcat Web Application Manager. Vamos editar o arquivo /etc/tomcat9/tomcat-users.xml e no final antes de adicionar adicionar as 2 linhas, não esqueça de alterar S3NHA_FORT3:

# vim /etc/tomcat9/tomcat-users.xml

  <role rolename="manager-gui"/>
  <user username="admin" password="S3NHA_FORT3" roles="manager-gui"/>

Arquivo /etc/tomcat9/tomcat-users.xml sem os comentários ficará:

<?xml version="1.0" encoding="UTF-8"?>
<tomcat-users xmlns="http://tomcat.apache.org/xml"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://tomcat.apache.org/xml tomcat-users.xsd"
              version="1.0">

  <role rolename="manager-gui"/>
  <user username="admin" password="S3NHA_FORT3" roles="manager-gui"/>
</tomcat-users>

:: Instalação Guacamole::

# apt install guacd

Os pacotes não criam os diretórios de configuração do Guacamole, então faremos conforme abaixo. Neles ficarão as extensions e o connector e que juntos integrarão o Java às bases de dados para funcionar a nossa autenticação e administração do Jump Server.

/etc/guacamole/
├── extensions
└── lib

# mkdir -p /etc/guacamole/lib /etc/guacamole/extensions

Crie um link simbólico do connector java do MariaDB no Guacamole:

# ln -s /usr/share/java/mariadb-java-client.jar /etc/guacamole/lib/

Vamos baixar e descompactar o pacote de extensão, para criação das tabelas e autenticação na base de dados. Detalhe que a versão tem que ser a mesma do pacote guacd que instalamos acima. Nesse caso é a versão 1.3.0 que vem no repositório do Debian 11.

# apt install wget
# cd /tmp
# wget -c https://archive.apache.org/dist/guacamole/1.3.0/binary/guacamole-auth-jdbc-1.3.0.tar.gz
# tar -xzvf guacamole-auth-jdbc-1.3.0.tar.gz

Mova a extensão de autenticação via MySQL, para o lugar correto:

# mv /tmp/guacamole-auth-jdbc-1.3.0/mysql/guacamole-auth-jdbc-mysql-1.3.0.jar /etc/guacamole/extensions/

Populando a base de dados guacamole com as tabelas e algumas informações iniciais:

# cat /tmp/guacamole-auth-jdbc-1.3.0/mysql/schema/*.sql | mysql -u root -p guacamole

Informe a senha do usuário MariaDB root no nosso ex.: “ALTERE_3ST4_SENHA”

Se desejar certificar que as tabelas foram criadas acesse o terminal do MariaDB com o usuário e senha do guacamole

# mariadb -u guacamole -p

Enter password: S3NHA_GUACAMOL3_US3R
Use o comando show tables; para ver as tabelas.

Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 9
Server version: 10.5.12-MariaDB-0+deb11u1 Debian 11

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [guacamole]> show tables; 
+---------------------------------------+
| Tables_in_guacamole                   |
+---------------------------------------+
| guacamole_connection                  |
| guacamole_connection_attribute        |
| guacamole_connection_group            |
| guacamole_connection_group_attribute  |
| guacamole_connection_group_permission |
| guacamole_connection_history          |
| guacamole_connection_parameter        |
| guacamole_connection_permission       |
| guacamole_entity                      |
| guacamole_sharing_profile             |
| guacamole_sharing_profile_attribute   |
| guacamole_sharing_profile_parameter   |
| guacamole_sharing_profile_permission  |
| guacamole_system_permission           |
| guacamole_user                        |
| guacamole_user_attribute              |
| guacamole_user_group                  |
| guacamole_user_group_attribute        |
| guacamole_user_group_member           |
| guacamole_user_group_permission       |
| guacamole_user_history                |
| guacamole_user_password_history       |
| guacamole_user_permission             |
+---------------------------------------+
23 rows in set (0.000 sec)

MariaDB [guacamole]> exit;
Bye

Criando o arquivo /etc/guacamole/guacamole.properties com as configurações de porta de acesso e os dados de conexão ao MariaDB.

# vim /etc/guacamole/guacamole.properties

Não esqueça de alterar S3NHA_GUACAMOL3_US3R

# Hostname and port of guacamole proxy
guacd-hostname: localhost
guacd-port:    4822

# MySQL properties
mysql-driver: mariadb
mysql-hostname: localhost
mysql-port: 3306
mysql-database: guacamole
mysql-username: guacamole
mysql-password: S3NHA_GUACAMOL3_US3R

OBS: Embora MariaDB e MySQL tenham algumas coisas em comum (MariaDB é um fork do Mysql), mas nesse caso eles são diferentes aqui. Em muitos artigos espalhados pela Internet se fala no pacote libmysql-java mas este não existe mais no Debian 11. No lugar dele usamos o libmariadb-java.

Baixando e habilitando o Guacamole Web Application

# ln -s /etc/guacamole/ /var/lib/tomcat9/.quacamole
# wget https://downloads.apache.org/guacamole/1.3.0/binary/guacamole-1.3.0.war -O /var/lib/tomcat9/webapps/guacamole.war
# systemctl restart tomcat9 guacd

Se parássemos por aqui, já teríamos o Guacamole rodando e funcional em HTTP, mas vamos adicionar uma camada de criptografia nisso. Vamos habilitar o SSL no Apache Tomcat:

Vamos criar uma chave e uma senha com o próximo comando. Só seguir as instruções e preencher as perguntas:

# keytool -genkey -alias tomcat -keyalg RSA

Informe a senha da área de armazenamento de chaves:  S3NHA_USADA_K3YTOOL
Informe novamente a nova senha: S3NHA_USADA_K3YTOOL
Qual é o seu nome e o seu sobrenome?
  [Unknown]:  Marcelo Gondim
Qual é o nome da sua unidade organizacional?
  [Unknown]:  AMA
Qual é o nome da sua empresa?
  [Unknown]:  LinuxInfo
Qual é o nome da sua Cidade ou Localidade?
  [Unknown]:  Araruama
Qual é o nome do seu Estado ou Município?
  [Unknown]:  RJ
Quais são as duas letras do código do país desta unidade?
  [Unknown]:  BR
CN=Marcelo Gondim, OU=AMA, O=LinuxInfo, L=Araruama, ST=RJ, C=BR Está correto?
  [não]:  sim

Concluído precisaremos movê-la para o local certo e com as devidas permissões:

# mv /root/.keystore /var/lib/tomcat9/
# chown tomcat. /var/lib/tomcat9/.keystore
# chmod 640 /var/lib/tomcat9/.keystore

Em /etc/tomcat9/server.xml:

# vim /etc/tomcat9/server.xml

Troque isso:

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

Por: (Não esqueça de alterar S3NHA_USADA_K3YTOOL)

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               maxThreads="200"
               scheme="https"
               secure="true"
               SSLEnabled="true"
               keystoreFile="/var/lib/tomcat9/.keystore"
               keystorePass="S3NHA_USADA_K3YTOOL"
               clientAuth="false"
               sslProtocol="TLS" />

# systemctl restart tomcat9 guacd

Para acessarmos nosso Jump Server:
https://[servidor]:8080/guacamole/

O usuário e senha são guacadmin. Crie um novo usuário com permissões de administrador e em seguida remova este usuário padrão.

Autor: Marcelo Gondim
Brasil Peering Fórum: https://wiki.brasilpeeringforum.org/w/Usuário:Gondim
Linkedin: https://www.linkedin.com/in/marcelo-gondim-sysadmin/
Telegram: @Marcelo_Gondim

Dicas extra do Remontti

Para complementar, tem algumas coisas que eu acho que podem serem aplicadas ao nosso Guacamole apresentado pelo nosso parceiro Marcelo Gondim

– Nginx fazendo Proxy reverso para acessar a aplicação com um subdomínio.
– Utilização do Let’s Encrypt para um certificado válido.
– Port knocking com Nftables, para não deixar totalmente exposto.

Proxy Nginx

Como a aplicação será acessada apenas pelo Nginx podemos deixar o tomcat9 ouvindo apenas em localhost, se você segui o procedimento anterio qual criou o certificado privado agora ele não é mais necessarios vamos desfazer para o que era antes porem vamos colocar o connector ouvindo apenas 127.0.0.1.

# vim /etc/tomcat9/server.xml

Altere para:

    <Connector address="127.0.0.1" port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

Reinicie o tomcat para que o mesmo rode apenas em localhost, assim não será mais possivel acesso pelo seu IP:8080

# systemctl restart tomcat9

Instalaremos o nginx e vamos remover a assinatura do nginx onde ele exibe a versão do mesmo.

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

Irei alterar direto no arquivo default do nginx as configurações, se achar melhor você pode criar um novo arquivo.

# mv /etc/nginx/sites-available/default /etc/nginx/sites-available/default.original
# vim /etc/nginx/sites-available/default

Adcione: (Altere server_name para seu subdomínio)

server {
    listen 80;
    listen [::]:80;
 
    server_name guacamole.remontti.com.br;

    location / {
        proxy_pass http://127.0.0.1:8080/guacamole/;
        proxy_buffering off;
        proxy_http_version 1.1;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $http_connection;
        proxy_cookie_path /guacamole/ /;
    }
}

# nginx -t
# systemctl restart nginx

Let’s Encrypt

# apt install certbot python3-certbot-nginx

Para gerar o certificado use o comando:

# certbot

Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator nginx, Installer nginx
Enter email address (used for urgent renewal and security notices)
 (Enter 'c' to cancel): noc@remontti.com.br

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server. Do you agree?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: y

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Would you be willing, once your first certificate is successfully issued, to
share your email address with the Electronic Frontier Foundation, a founding
partner of the Let's Encrypt project and the non-profit organization that
develops Certbot? We'd like to send you email about our work encrypting the web,
EFF news, campaigns, and ways to support digital freedom.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: n
Account registered.

Which names would you like to activate HTTPS for?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: guacamole.remontti.com.br
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate numbers separated by commas and/or spaces, or leave input
blank to select all options shown (Enter 'c' to cancel): 1
Requesting a certificate for guacamole.remontti.com.br
Performing the following challenges:
http-01 challenge for guacamole.remontti.com.br
Waiting for verification...
Cleaning up challenges
Deploying Certificate to VirtualHost /etc/nginx/sites-enabled/default
Redirecting all traffic on port 80 to ssl in /etc/nginx/sites-enabled/default

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Congratulations! You have successfully enabled
https://guacamole.remontti.com.br
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/guacamole.remontti.com.br/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/guacamole.remontti.com.br/privkey.pem
   Your certificate will expire on 2022-04-17. To obtain a new or
   tweaked version of this certificate in the future, simply run
   certbot again with the "certonly" option. To non-interactively
   renew *all* of your certificates, run "certbot renew"
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

Não esqueça de colocar no seu cron para ele renovar o certificado, pois a cada 90 ele expira. Neste exemplo todo dia primeiro tento renovar.

# certbot -q renew

Exemplo:

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

Port knocking

Nftables já vem por padrão no Debian 11 então basta habilitá-lo. Temos um tutorial do se Port knocking

# systemctl enable nftables

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

# vim /etc/nftables.conf

Neste exemplo vou estar liberando as portas 80 e 443 após “batermos” nas portas 52341, 28001, 60541, 30951, e por 2h (7200s) após bater nas portas teremos acesso as mesmas, caso fique mais que tempo definido será necessário bater novamente.

#!/usr/sbin/nft -f

flush ruleset

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

define protege_portas = {80,443}

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 7200s} log prefix "Portknock bem-sucedido: "
      tcp dport 30951 ip6 saddr . tcp dport @toctoc_aberta_ipv6 add @clientes_ipv6 {ip6 saddr timeout 7200s} 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
   }
}

Reinicie o nftables

# systemctl restart nftables

Neste tutorial de Port knocking tenho um modelinho web qual você pode usar, existe alguns clientes para celular Android, iPhone e Windows.

Agora deixamos mais seguro nosso servidor.

Exemplo de como adicionar um Windows Server ao seu guacamole

No canto superior direito, clique no nome de usuário e em seguida Settings.

Click em Connections em seguida New Connection

EDIT CONNECTION
Name: Insira um nome de identificação para a conexão
Location: Use o ROOT padrão se não houver requisitos específicos
Protocol: RDP

PARAMETERS
Network
Hostname: IP o Domínio do seu Servidor
Port: Podemos deixá-lo vazio se usar a porta padrão 3389, ou informe a porta alterada do RDP
Authentication
Username: Usuário
Password: Senha
Domain: Deixe em branco ou use o nome de domínio local do dispositivo Windows
Ignore server certificate: Marque esta opção se o certificado for autoassinado

Role para baixo até o final da página e clique no botão Save.

A interface é bem intuitiva, acredito que não terá dificuldades, você pode criar grupos e usuarios e restrigir o acesso apenas a alguns servidores.

Espero que tenha gostado! E mais uma vez deixo meu agradecimento ao parceio Marcelo Gondim. Para trocar uma ideia chega lá no telegram @remontticombr

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.

Referências:
– https://wiki.debian.org/Guacamole
– https://computingforgeeks.com/install-and-use-guacamole-remote-desktop-on-debian/
– https://wiki.brasilpeeringforum.org/w/Configurando_um_gateway_de_acesso_remoto_com_Guacamole
– https://receitasdecodigo.com.br/web/configurando-ssl-no-tomcat-8

O post Aprenda a instalar um Jump Server com Apache Guacamole um gateway de desktop remoto Web apareceu primeiro em Remontti.

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

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

Requesitos:
Debian 11 Bullseye – Instalação Limpa

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

Ajustando o repositório

# vim /etc/apt/sources.list

Adicione contrib non-free aos repositórios

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

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

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

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

Atualize o repositório:

# apt update

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

# apt upgrade -y

Intale os firmware-linux*

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

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

# reboot

Pré-requisitos:
– Node.js
– MongoDB

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

# apt install curl gnupg2 wget

Instalção do Node.js

Repositório Node Js

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

Verifique a versão

# npm -v

Veja se não tem atualização

# npm search -g npm

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

# npm install -g npm@9.6.7

Instalação do MongoDB

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

Versão 5 (Recomendada)

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

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

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

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

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

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

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

Instalação do GenieACS

Procure se o pacote existe:

# npm search -g genieacs

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

Instale o genieacs

# npm install -g genieacs

added 129 packages in 8s

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

Crie um usuário do sistema para executar daemons GenieACS

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

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

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

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

# vim /opt/genieacs/genieacs.env

Adicione:

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

Defina a propriedade e as permissões do arquivo:

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

Criar diretório de logs

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

Configure os serviços no systemd

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

Adicione:

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

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

[Install]
WantedBy=default.target

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

Adicione:

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

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

[Install]
WantedBy=default.target

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

Adicione:

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

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

[Install]
WantedBy=default.target

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

Adicione:

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

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

[Install]
WantedBy=default.target

Configure o logrotate para rotação dos log gerados

# vim /etc/logrotate.d/genieacs

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

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

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

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

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

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

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

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

Clique em: ABRACADABRA!

Clique em: Open Sesame!

Entre com: admin/admin

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

Gostou? Quer ajudar manter o blog?

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

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

O post TR-069 – Instalação do GenieACS no Debian 11 Bullseye apareceu primeiro em Remontti.

Ante de iniciar a instalação é preciso saber como funciona um DNS:

DNS Recursivo
O DNS recursivo é responsável pela resolução de nomes, começando sempre com consultas recursivas nos servidores raízes. Para melhorar a eficiência, reduzir o tráfego DNS na Internet e aumentar o desempenho em aplicativos de usuário final, utilizamos o cache de DNS, armazenando resultados das consulta DNS por um período de tempo determinado na configuração (tempo de vida determinado pelo autoritativo do domínio consultado).

DNS Autoritativo
É o serviço DNS que possui autoridade sob um domínio. Assim, como o servidor ns1.remontti.com.br é o DNS autoritativo de meu domínio remontti.com.br, é ele que sempre vai responder qualquer subdomínio ou “hosts” (por exemplo: blog.remontti.com.br).
É nesse servidor que você vai apontar nas configurações de um domínio registrado no registro.br, por exemplo.

DNS Reverso
DNS atua resolvendo o nome do domínio/subdomínio para um endereço IP correspondente. Já o DNS Reverso, como o próprio nome diz, resolve o endereço IP para o nome de domínio associado ao host. Ou seja, quando temos disponível o endereço IP de um host e não sabemos o endereço do domínio (nome dado à máquina ou outro equipamento que acesse uma rede), tentamos resolver o endereço IP através do DNS reverso que procura qual nome de domínio está associado aquele endereço.
Os servidores que utilizam o DNS Reverso conseguem verificar a autenticidade de endereços, verificando se o endereço IP atual corresponde ao endereço IP informado pelo servidor DNS.
Isto evita que alguém utilize um domínio que não lhe pertence para enviar spam, por exemplo (por isso que ele é importante para servidores de e-mail).

Correção dos dados de geolocalização
É muito importante que sua geolocalização estaja correta no maxmind.com, verifique alguns de de seus IPs.
https://www.maxmind.com/en/geoip-demo

Para correção temos dois formulários.
Correct a GeoIP Location
https://support.maxmind.com/geoip-data-correction-request/correct-a-geoip-location/
Correct a GeoIP ISP or Organization
https://support.maxmind.com/geoip-data-correction-request/correct-a-geoip-isp-or-organization/

Instalação do Debian

Requesitos:
Debian 12 Bookworm – Instalação Limpa (Recomendado)
Debian 11 Bullseye – Instalação Limpa

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

Vire root com o comando correto!

# su - 

No Debian 12 o rsyslog foi abandonado como sistema de logs e esta usando systemd-journald. Como o bind salva alguns logs em arquivo e o fail2ban lê os mesmo vamos precisar dele, para isso instale o mesmo:

# apt install rsyslog

Instalação fail2ban e nftables (Master/Slave)

Fail2Ban é uma estrutura de software de prevenção de intrusões que protege os servidores contra ataques de força bruta. Ele opera monitorando arquivos de logs, sendo o mais comum seu uso para bloquear endereços IPs que podem pertencer à hosts que estão tentando violar a segurança do seu servidor.
nftables é um firewall baseado no iptables que agora no Debian 11 já vem instalado por padrão subistituindo o antigo iptables.

# apt install fail2ban

Entendo o funcionamento do fail2ban:

# fail2ban-client status

Por padrão o filtro de SSH já vem habilitado, então seu SSH (porta 22) já está “protegida”, se alguém errar a senha por 5 vezes terá seu IP bloqueado por 10 minutos.

Status
|- Number of jail:      1
`- Jail list:   sshd

Para alterar esses padrões de tempo e número de tentativas edite: (este arquivo é muito bem comentado o que cada variável faz!)

# vim /etc/fail2ban/jail.conf

Localize as linhas, e ajuste de acordo com suas necessidades

bantime  = 10m
findtime  = 10m
maxretry = 5

Se desejar desativar o filtro de SSH

# vim /etc/fail2ban/jail.d/defaults-debian.conf

Altere para false

[sshd]
enabled = false

Porém como eu sempre altero a porta do SSH de todo o servidor bem como tempo para digitar a senha, é natural que o fail2ban não ira poteger caso você tenha alterado a mesma. Inclusive recomendo você adotar essa boa pratica.

# vim /etc/ssh/sshd_config

Em Port defina a nova porta, e LoginGraceTime defina o tempo em segundos para digitar a senha, e nunca seja ignorante de permitir o acesso root direto no SSH em PermitRootLogin, a não ser que tenha uma forte motivo para isso (Me conte nos comentários, até hoje não tive motivo para tal!)

Port 60002
LoginGraceTime 10
#PermitRootLogin prohibit-password # Nao seja burro de colocar um yes aqui!

Com a porta alterada do SSH (como no exemplo 60002) vamos ajusta no fail2ban para proteger essa nova porta

# vim /etc/fail2ban/jail.conf

Localize e adicione 60002:

[sshd]
Port = ssh,60002

Por padrão de segurança do fail2ban usa o iptables e faz o bloquei apenas da porta do serviço que esta sofrendo o “ataque”, vamos subistituir o iptables pelo nftables ou por route. Vou deixar os dois modelos a baixo de exemplo.

nftables: Em vez de usar o filtro multiport, vou setar allports e modificá-lo para que tentativas de violação crie uma regra de firewall de drop e não reject definitivamente o IP e não apenas fechando a porta do serviço. Para isso edite:

# vim /etc/fail2ban/jail.conf

Localize banaction e banaction_allports e altere para nftables-allports:

banaction = nftables-allports
banaction_allports = nftables-allports

Para bloquear tudo e não apenas a porta do serviço atacada:

# vim /etc/fail2ban/action.d/nftables.conf

Localize rule_match-allports e remova o meta l4proto \{ \} ficando:

rule_match-allports =

Ainda no altere o blocktype de reject para drop

blocktype = drop

Habilite o nftblaes para o boot do sistema, em seguida reinicie os serviços

# systemctl enable nftables
# systemctl restart nftables fail2ban

Verifique se mesmo estão rodando sem nenhum erro:

# systemctl status nftables fail2ban

route: Com o método route iremos em vezes de criar uma regra de firewall para o IP que esta “atacando” vamos coloca-lo em blackhole, assim se você possuir algum roteamento já poderá exportar o IP para sua borda para matar lá já (gosto + dessa).

# vim /etc/fail2ban/jail.conf

Localize banaction e banaction_allports e altere para route:

banaction = route
banaction_allports = route

Vamos ajustar agora para ação ser blackhole

# vim /etc/fail2ban/action.d/route.conf

Em blocktype altere para blackhole

blocktype = blackhole

# systemctl restart fail2ban

Se tiver acesso a outro servidor externo tente fazer uma conexão SSH, e erre varias vezes a senha para ser bloqueado, assim você pode validar seu fail2ban.

Para visualizar seu firewall nftables use o comando:

# nft list ruleset

Ou se usou route para mostra a tabela de rotas:

# ip route list
# ip -6 route list

Alguns comandos úteis do fail2ban
Visulizar os filtros

# fail2ban-client status

Visualizar detalhe de um filtro

# fail2ban-client status NOME_FILTRO
# fail2ban-client status sshd

Remover um IP de um determinado filtro

# fail2ban-client set sshd unbanip IPADDRESS
# fail2ban-client set sshd unbanip 200.200.200.200

Exemplo de script para remover todos os IPs banidos uma a um.

#!/bin/bash
BANIDOS=`fail2ban-client status bind9 | grep "Banned IP list" | awk '{$1=$2=$3=$4=$5=""; print $0}'`
IPS=$(echo $BANIDOS | tr " " "\n")
for IP in $IPS
 do
  #echo "Removendo: ${IP}"
  fail2ban-client set bind9 unbanip ${IP} ;
  #ip route del ${IP}
done

Se desejar adicionar algum prefixo a uma lista branca você pode editar:

# vim /etc/fail2ban/jail.conf

Localize ignoreip, desomente a linha (remova o # da frete) e adicione os prefixo que deseja ignorar, para não cair bloqueio.

ignoreip = 127.0.0.1/8 ::1 200.200.200.0/22 2000:2000::/32

Reinicie o serviço

# systemctl restart fail2ban

Instalação do Bind9 (Master/Slave)

Instalação dos pacotes

# apt install bind9 dnsutils

Arquitetura de arquivos e diretórios do bind9 no Debian 11:

/etc/bind/
├── bind.keys
├── db.0
├── db.127
├── db.255
├── db.empty
├── db.local
├── named.conf
├── named.conf.default-zones
├── named.conf.local
├── named.conf.options
├── rndc.key
└── zones.rfc1918
/usr/share/dns/
├── root.ds
├── root.hints
├── root.hints.sig
└── root.key
/var/cache/bind/
├── managed-keys.bind
└── managed-keys.bind.jnl

Configuração do Recursivo

Alteramos o DNS do servidor fazendo com que ele consulte em si próprio, através dos IPs de loopback. Essa alteração deve ser feita no arquivo /etc/resolv.conf.

# echo "nameserver 127.0.0.1" > /etc/resolv.conf
# echo "nameserver ::1" >> /etc/resolv.conf

Para validar se seu servidor conseguer resolver nomes nele próprio, use o comando dig e host. Alguns comandos de Ex:

# dig @localhost google.com.br 
# dig @127.0.0.1 google.com.br 
# dig @::1 google.com.br +short
# host google.com.br

Como identificar o problema com resoluções de nomes, famoso: “Meu DNS não está resolvendo nomes!”. Use o atributo +trace, assim o mesmo mostrará todo o caminho feito para a resolução, assim você ira identificar onde “parou” e não obteve a informação necessária. Ex:

# dig @localhost google.com.br +trace

Observe as linhas em destaque.

; <<>> DiG 9.16.15-Debian <<>> @localhost google.com.br +trace
; (2 servers found)
;; global options: +cmd
.                       517911  IN      NS      b.root-servers.net.
.                       517911  IN      NS      c.root-servers.net.
.                       517911  IN      NS      m.root-servers.net.
.                       517911  IN      NS      a.root-servers.net.
.                       517911  IN      NS      l.root-servers.net.
.                       517911  IN      NS      k.root-servers.net.
.                       517911  IN      NS      e.root-servers.net.
.                       517911  IN      NS      i.root-servers.net.
.                       517911  IN      NS      d.root-servers.net.
.                       517911  IN      NS      f.root-servers.net.
.                       517911  IN      NS      g.root-servers.net.
.                       517911  IN      NS      h.root-servers.net.
.                       517911  IN      NS      j.root-servers.net.
.                       517911  IN      RRSIG   NS 8 0 518400 20211107...
;; Received 1137 bytes from ::1#53(localhost) in 0 ms

br.                     172800  IN      NS      f.dns.br.
br.                     172800  IN      NS      e.dns.br.
br.                     172800  IN      NS      b.dns.br.
br.                     172800  IN      NS      c.dns.br.
br.                     172800  IN      NS      d.dns.br.
br.                     172800  IN      NS      a.dns.br.
br.                     86400   IN      DS      2471 13 2 5E4F35...
br.                     86400   IN      RRSIG   DS 8 1 86400 202...
;; Received 741 bytes from 198.41.0.4#53(a.root-servers.net) in 140 ms

google.com.br.          3600    IN      NS      ns1.google.com.
google.com.br.          3600    IN      NS      ns2.google.com.
google.com.br.          3600    IN      NS      ns3.google.com.
google.com.br.          3600    IN      NS      ns4.google.com.
uh3thc9qu1qbt25pspmqnbuvm420ur2e.com.br. 900 IN NSEC3 1 1 10 A8A465B84D7...
uh3thc9qu1qbt25pspmqnbuvm420ur2e.com.br. 900 IN RRSIG NSEC3 13 3 900 202...
hekajlrgmga91msd4es7bmhol7dbtbbi.com.br. 900 IN NSEC3 1 1 10 A8A465B84D7...
hekajlrgmga91msd4es7bmhol7dbtbbi.com.br. 900 IN RRSIG NSEC3 13 3 900 202...
;; Received 507 bytes from 2001:12f8:a::10#53(c.dns.br) in 140 ms

google.com.br.          300     IN      A       142.250.219.195
;; Received 58 bytes from 2001:4860:4802:38::a#53(ns4.google.com) in 144 ms

Primeiramente consultamos os root servers, que estão em nosso servidor essa info, logo perceba que ele fez a consulta dos root servers em localhost, em seguida um dos root servers falou para ele que é são os DNS responsáveis do .br e no exemplo ele escolheu o a.root-servers.net, que falou para ele quem são os DNS fo google, e o DNS do google, neste cado o c.dns.br falou qual é o IPv4 (A) do google.com.br = 42.250.219.195, o valor 300 é o tempo que seu servidor irá armazenar essa resposta em cache. Eu levaria muito tempo para explicar aqui, então quando tiver um curso meu de DNS não fique de fora

Configurando Recursivo no DNS Master

Nesse cenário vou usar os prefixos 45.80.48.0/22 e 2804:f123::/32 (desculpe caso seja de alguém)

Edite:

# vim /etc/bind/named.conf.options

A explicação de todos os campos e variáveis estão nos comentários do arquivo:

// ACL "autorizados" essa colocamos os IPs que são autorizados a fazer consultas recursivas neste servidor.
// Neste caso vou incluir os IPs que foram nos delegados bem como de localhost e todos IPs privados.
acl autorizados {
        127.0.0.1;
        ::1;
        192.168.0.0/16;
        172.16.0.0/12;
        100.64.0.0/10;
        10.0.0.0/8;
        2001:db8::/32; 
        fd00::/8; 
        fe80::/10; 
        fc00::/8;        
        45.80.48.0/22;
        2804:f123::/32;
}; 

options {
    // O diretório de trabalho do servidor
    // Quaisquer caminho não informado será tomado como padrão este diretório
    directory "/var/cache/bind";
 
    //Suporte a DNSSEC
    dnssec-validation auto;
 
    // Conforme RFC1035
    // https://www.ietf.org/rfc/rfc1035.txt
    // Se o servidor deve responder negativamente (NXDOMAIN) para consultas de domínios que não existem.
    auth-nxdomain no;
 
    // Respondendo para IPv4 e IPv6
    // Porta 53 estará aberta para ambos v4 e v6 (pode ser informar apenas os IPs que ficarão ouvindo)
    // ex listen-on { 127.0.0.1; 45.80.48.2; }; 
    // ex listen-on-v6 { ::1; 2804:f123:bebe:cafe::2; };
    // ou any para todos os IPs das interfaces (recomendado, pricipalmente em anycast)
    listen-on { any; };
    listen-on-v6 { any; };
 
    // Serve como uma ferramenta de mitigação para o problema de ataques de amplificação de DNS
    // No momento, a implementação de RRL (Response Rate Limiting)é recomendada apenas para servidores autoritativos
    // Se seu servidor será apenas autoritativo descomente as linhas a baixo. (https://kb.isc.org/docs/aa-00994)
    //rate-limit {
    //    responses-per-second 15;
    //    window 5;
    //};
 
    // Informações adicionais em suas respostas DNS
    // Melhora o desempenho do servidor, reduzindo os volumes de dados de saída.
    // O padrão BIND é (no) não.
    minimal-responses yes;

    // Reduzir o tráfego da rede e aumentar o desempenho, o servidor armazena respostas negativas.
    // é usado para definir um tempo máximo de retenção para essas respostas no servidor. (segundos)
    // Determina por quanto tempo o servidor irá acreditar nas informações armazenadas em cache de 
    // respostas negativas (NXDOMAIN) antes de buscar novamente informações.
    max-ncache-ttl 300;

    // Desativar recursão. Por padrão já é yes.
    // recursion no;
 
    // Especifica quais hosts estão autorizados a fazer consultas
    // recursivas através deste servidor.
    // Aqui que você vai informar os IPs da sua rede que você irá permitir consultar os DNS.
    allow-recursion { autorizados; };
 
    // Endereço estão autorizados a emitir consultas ao cache local,
    // sem acesso ao cache local as consultas recursivas são inúteis.
    allow-query-cache { autorizados; };
 
    // Especifica quais hosts estão autorizados a “fazer perguntas” ao seu DNS. 
    // Se for apenas recursivo pode informa a ACL “autorizados” 
    // allow-query { autorizados; };
    allow-query { any; };
 
    // Especifica quais hosts estão autorizados a receber transferências de zona a partir do servidor.
    // Seu servidor Secundário, no nosso ex vou deixar então o ips dos dois servidores v4 e v6.
    allow-transfer {
        45.80.48.3;
        2804:f123:bebe:cafe::3;
    };
    also-notify {
        45.80.48.3;
        2804:f123:bebe:cafe::3;
    };
 
    // Esta opção faz com que o servidor slave ao fazer a transferência de zonas
    // mastes deste servidor no formato binário (raw) do arquivo ou texto (text)
    // text será legível por humanos, já raw formato é mais eficiente em termos de desempenho.
    // masterfile-format raw;
    masterfile-format text;

    // Para evitar que vase a versao do Bind, definimos um nome
    // Reza a lenda que deixar RR DNS Server seu servidor nunca sofrerá ataques.
    version "RR DNS Server – Do good";

    // Define a quant. máxima de memória a ser usada para o cache do servidor (bytes ou porcentagem)
    // Por padrão no debian 10/bind9 ele reserva 90% da memoria física. Então não se apavore com log ex.:
    // Servidor com 2GB: none:106: 'max-cache-size 90%' - setting to 1795MB (out of 1994MB)
    // Recomendo não alterar
    // max-cache-size 512M;
    // max-cache-size 50%;

    // Isso define o tempo mínimo para o qual o servidor armazena 
    // em cache as respostas positivas, em segundos.
    // Ex o tiktok.com manda tempo de ttl de 20 segundos, 
    // e você quer ignorar esse valor 20 e setar que o minimo seja 90.
    // que é o máximo permitido.
    min-cache-ttl 90;

    // Não recomendado alterar para menos que 24h.
    // Define o tempo máximo durante o qual o servidor armazena (informado pelo dono do domínio)
    // em cache as respostas positivas, em segundos. O max-cache-ttl padrão é 604800 (uma semana) 
    // max-cache-ttl 86400; // 24h 

};

Leitura recomendada:
https://bind9.readthedocs.io/en/latest/reference.html
https://downloads.isc.org/isc/bind9/9.11.24/doc/arm/Bv9ARM.ch06.html

Para verificar se seu arquivo tem algum erro use o comando named-checkconf

# named-checkconf /etc/bind/named.conf.options

Imprime todas as configurações

# named-checkconf -p

Bem útil para você mandar suas conf quando esta com algum problema lá no grupo do telegram

Reinicie o bind9 para que as novas configurações sejam carregadas, e verifique se o serviço subiu sem erros.

# systemctl restart bind9
# systemctl status bind9

# systemctl restart bind9
# systemctl status bind9

Configurando Recursivo (Slave)

Não esqueça da parte do fail2ban e nftables.

# vim /etc/bind/named.conf.options

Já explicado no master, a diferença aqui aqui não temos os campos allow-transfer e also-notify, já que ele é o servidor secundário.

acl autorizados {
        127.0.0.1;
        ::1;
        192.168.0.0/16;
        172.16.0.0/12;
        100.64.0.0/10;
        10.0.0.0/8;
        2001:db8::/32; 
        fd00::/8; 
        fe80::/10; 
        fc00::/8;        
        45.80.48.0/22;
        2804:f123::/32;
}; 

options {
    directory "/var/cache/bind";
    dnssec-validation auto;
    auth-nxdomain no;
    listen-on { any; };
    listen-on-v6 { any; };
    minimal-responses yes;
    max-ncache-ttl 300;
    allow-recursion { autorizados; };
    allow-query-cache { autorizados; };
    //allow-query { autorizados; }; //Se apenas for recursivo
    allow-query { any; };
    allow-transfer { none; };
    masterfile-format text;
    version "RR DNS Server";
};

Reinicie o bind9 para que as novas configurações sejam lidas, e verifique se o serviço subiu sem erros.

# systemctl restart bind9
# systemctl status bind9

Colocando o fail2ban para protege seu DNS (Master/Slave)

Ele irá ler os logs do bind com tentativas de consultas negadas (denied), para isso precisamos configurar nosso bind para gerar tal logs.Faça isso no Mastere Slave.

# vim /etc/bind/named.conf

Adicione logging { … }:

// This is the primary configuration file for the BIND DNS server named.
//
// Please read /usr/share/doc/bind9/README.Debian.gz for information on the 
// structure of BIND configuration files in Debian, *BEFORE* you customize 
// this configuration file.
//
// If you are just adding zones, please do that in /etc/bind/named.conf.local

logging {
 
    channel security_file {
        file "/var/log/named/security.log" versions 3 size 30m;
        severity dynamic;
        print-time yes;
    };
 
    channel file_log {
        file "/var/log/named/bind.log" versions 3 size 1m;
        severity info;
        #severity debug 3;
        print-time yes;
        print-severity yes;
        print-category yes;
    };
 
    channel dnssec_log {
        file "/var/log/named/dnssec.log" versions 3 size 1m;
        severity warning;
        print-time yes;
    };
 
    category security { security_file; };
    category default { file_log; };
    category dnssec { dnssec_log; };
    category lame-servers { null; };
    category edns-disabled { null; };
    category resolver { null; };
    category unmatched { null; };
 
};

include "/etc/bind/named.conf.options";
include "/etc/bind/named.conf.local";
include "/etc/bind/named.conf.default-zones";

Crie o diretório onde o bind vai registrar seus logs e dê permissão para que ele possa gravar nesta pasta.

# mkdir /var/log/named/
# chown bind: /var/log/named/

Reinicie o serviço

# systemctl restart bind9

Iremos criar um filtro para ler os logs do bind

# vim /etc/fail2ban/filter.d/bind9.conf

Adicione:

# Fail2Ban filter file for named (bind9).
# v9.18.x

# This filter blocks attacks against named (bind9) however it requires special
# configuration on bind.
#
# By default, logging is off with bind9 installation.
#
# You will need something like this in your named.conf to provide proper logging.
#
# logging {
#     channel security_file {
#         file "/var/log/named/security.log" versions 3 size 30m;
#         severity dynamic;
#         print-time yes;
#     };
#     category security {
#         security_file;
#     };
# };

[Definition]

# Daemon name
_daemon=named(?:-\w+)?

# Shortcuts for easier comprehension of the failregex

__pid_re=(?:\[\d+\])
__daemon_re=\(?%(_daemon)s(?:\(\S+\))?\)?:?
__daemon_combs_re=(?:%(__pid_re)s?:\s+%(__daemon_re)s|%(__daemon_re)s%(__pid_re)s?:)

_category = (?!error|info)[\w-]+
_category_re = (?:%(_category)s: )?

#       hostname       daemon_id         spaces
# this can be optional (for instance if we match named native log files)
__line_prefix=\s*(?:\S+ %(__daemon_combs_re)s\s+)?%(_category_re)s

prefregex = ^%(__line_prefix)s(?:(?:error|info):\s*)?client(?: @\S*)? <HOST>#\S+(?: \([\S.]+\))?: <F-CONTENT>.+</F-CONTENT>\s(?:denied|denied \(allow-query-cache did not match\)|\(NOTAUTH\))\s*$

failregex = ^(?:view (?:internal|external): )?query(?: \(cache\))?
            ^zone transfer
            ^bad zone transfer request: '\S+/IN': non-authoritative zone

ignoreregex =

# DEV Notes: Debian 12
# Author: Rudimar Remontti

Ativamos o filtro que criamos, e definimos o tempo de banimento para 12h, se você desejar pode ajustar para mais ou menos se achar necessário. E “maxretry” que é a quantidade de tentativas usaremos 1, limitando a 1 tentativa (não recomendo alterar) apenas para já ser bloqueado.

# vim /etc/fail2ban/jail.d/bind9.conf

[bind9]
enabled  = true
port     = domain,953
protocol = tcp
logpath  = /var/log/named/security.log
bantime  = 12h
maxretry = 1

Em seguida ativamos reinciamos os serviços.

# systemctl restart fail2ban
# systemctl status fail2ban

Consulte se o filtro bind9 foi carregado

# fail2ban-client status

Status
|- Number of jail:      2
`- Jail list:   bind9, sshd

Para validar realize um teste de um servidor externo não autorizado à resolver nomes em seu servidor com o comando dig, ex:

# dig @ip_so_seu_dns google.com.br

Deixe rodando o comando para visualizar os logs.

# tail -f /var/log/named/security.log

Log como ira aparecer, onde 192.168.254.198 é o IP que tentou resolver nomes e google.com.br foi o dóminio.

25-Oct-2021 17:57:09.284 client @0x7f79e80104c8 192.168.254.198#63239 (google.com.br): query (cache) 'google.com.br/A/IN' denied

Verificando agora o fail2ban vamos encontrar o IP 192.168.254.198 em Banned IP list.

# fail2ban-client status bind9

Status for the jail: bind9
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     1
|  `- File list:        /var/log/named/security.log
`- Actions
   |- Currently banned: 1
   |- Total banned:     1
   `- Banned IP list:   192.168.254.198

Verificando as regras do firewall nftables também iremos encontra-lo.

# nft list ruleset

table inet filter {
        chain input {
                type filter hook input priority filter; policy accept;
        }

        chain forward {
                type filter hook forward priority filter; policy accept;
        }

        chain output {
                type filter hook output priority filter; policy accept;
        }
}
table inet f2b-table {
        set addr-set-bind9 {
                type ipv4_addr
                elements = { 192.168.254.198 }
        }

        chain f2b-chain {
                type filter hook input priority filter - 1; policy accept;
                ip saddr @addr-set-bind9 drop
        }
}

Para remover o IP basta:

# fail2ban-client set bind9 unbanip 192.168.254.198

Atualização dos Roots servers

Não é comum os Roots Servers terem alguma alteração, mas é algo que ao logo desses anos vi acontecer já, então caso um dia precise atualiza-los. Primeiramente renomei o arquivo atual root.hints

# mv /usr/share/dns/root.hints /usr/share/dns/root.hints.`date +%Y%m%d`

Agora vamos baixar a versão mais recente.

# apt install wget 
# wget https://www.internic.net/domain/named.root -O /usr/share/dns/root.hints

Para visualizar se tem alguma diferença entre os arquivos execute o comando:

# diff /usr/share/dns/root.hints /usr/share/dns/root.hints.`date +%Y%m%d`

Perceba que o que mudou apenas foi a data em last update. Resto do arquivo continua igual.

11,13c11,13
< ;
< ;       last update:     October 14, 2021
< ;       related version of root zone:     2021101401
---
> ; 
> ;       last update:     January 11, 2021 
> ;       related version of root zone:     2021011101

Desativar IPv6 do bind

Se por algum motivo precisar desabilitar faça:

# vim /etc/default/named

OPTIONS="-u bind"

Para

OPTIONS="-4 -u bind"

# vim /etc/bind/named.conf.options

listen-on-v6 { any; };

Para

listen-on-v6 { none; };

Reinicie o serviço

# systemctl restart bind

Configurando um proxy do DNS recursivo

Está confiuração deixará de usar os Root Serves e irá fazer as consultar em outros servidores DNS, e armazenar no seu cache local.

# vim /etc/bind/named.conf.options

Adicione dentro de options { ….. }

  recursion yes;
  forwarders {
      8.8.8.8;
      1.1.1.1;
      1.0.0.1;
      8.8.4.4;
  };
  forward only;

Comando dig

Algumas coisas que você precisa saber, ex:

# dig google.com.br @localhost

; <<>> DiG 9.16.15-Debian <<>> google.com.br @localhost
; <<>> DiG 9.16.15-Debian <<>> google.com.br @localhost
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 49083
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 4, ADDITIONAL: 9

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 595c2c7eb1d62205010000006177f1e2e08119b0ec4133aa (good)
;; QUESTION SECTION:
;google.com.br.                 IN      A

;; ANSWER SECTION:
google.com.br.          300     IN      A       172.217.173.67

;; AUTHORITY SECTION:
google.com.br.          3599    IN      NS      ns1.google.com.
google.com.br.          3599    IN      NS      ns4.google.com.
google.com.br.          3599    IN      NS      ns3.google.com.
google.com.br.          3599    IN      NS      ns2.google.com.

;; ADDITIONAL SECTION:
ns1.google.com.         172800  IN      AAAA    2001:4860:4802:32::a
ns2.google.com.         172800  IN      AAAA    2001:4860:4802:34::a
ns3.google.com.         172800  IN      AAAA    2001:4860:4802:36::a
ns4.google.com.         172800  IN      AAAA    2001:4860:4802:38::a
ns1.google.com.         172800  IN      A       216.239.32.10
ns2.google.com.         172800  IN      A       216.239.34.10
ns3.google.com.         172800  IN      A       216.239.36.10
ns4.google.com.         172800  IN      A       216.239.38.10

;; Query time: 1560 msec
;; SERVER: ::1#53(::1)
;; WHEN: ter out 26 09:17:38 -03 2021
;; MSG SIZE  rcvd: 344

O resultado retornará algumas seções, porém como configuramos no named.conf.options minimal-responses yes, iremos ter apenas 3. Isso deixa seu DNS mais otimizado, além do mais yes é o padrão agora na versão 9.16 do bind, caso queira testar experimente setar em: no.

; <<>> DiG 9.16.15-Debian <<>> google.com.br @localhost
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 13858
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 38763b6c79757a2a010000006177f255c6a6a6d3e4833e77 (good)
;; QUESTION SECTION:
;google.com.br.                 IN      A

;; ANSWER SECTION:
google.com.br.          300     IN      A       172.217.173.67

;; Query time: 1524 msec
;; SERVER: ::1#53(::1)
;; WHEN: ter out 26 09:19:33 -03 2021
;; MSG SIZE  rcvd: 86

HEADER: Ela contém diversas informações a respeito da consulta.

;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 49083
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 4, ADDITIONAL: 9

- status indica o tratamento de erro nas consultas, sendo eles:
-- NOERROR: Nenhum erro encontrado, ou seja, sucesso.
-- SERVFAIL: Houve algum problema com o servidor, que não conseguiu processar a query.
-- NXDOMAIN: Significa que o domínio pesquisado não existe.
-- REFUSED: O servidor rejeitou a solicitação.
-flags: indicador das opções de recursividade e de autoridade, em resumo este conjunto de “letrinhas” (aa, rd, ra, etc), indica o estado ligado/desligado RFC1035
-- qr: se a mensagem é uma query (0) ou uma resposta (1). Como estamos avaliando somente as respostas, este bit sempre estará ligado (consequentemente, sempre veremos a string “qr” no campo “flags“).
-- aa: que o servidor que respondeu à solicitação é autoritativo do domínio.
-- rd: que a query é recursiva, que as requisições devem ser encaminhadas a outros servidores até que o servidor autoritativo seja encontrado.
-- ra: que o servidor que respondeu à requisição suporta consultas recursivas.
-- tc: que a mensagem de resposta está truncada.
-- z: reservado para uso futuro.
- contadores: na mesma linha das flags, econtramos quantos resultados vieram nas sessões.

QUERY: 1, ANSWER: 1, AUTHORITY: 4, ADDITIONAL: 9

QUESTION
Replica a query que foi enviada para consulta, por padão quando não passa A = IPv4

;; QUESTION SECTION:
;google.com.br.                 IN      A

Outros exemplos:

# dig AAAA google.com.br @localhost
# dig MX google.com.br @localhost
# dig NS google.com.br @localhost
# dig TXT google.com.br @localhost
# dig ANY google.com.br @localhost

ANSWER
Contém a resposta para a consulta que foi enviada.

;; ANSWER SECTION:
google.com.br.          86400   IN      CAA     0 issue "pki.goog"
google.com.br.          60      IN      SOA     ns1.google.com. dns-admin.google.com. 405356128 900 900 1800 60
google.com.br.          300     IN      AAAA    2800:3f0:4001:819::2003
google.com.br.          300     IN      A       172.217.173.67
google.com.br.          300     IN      MX      0 smtp.google.com.
google.com.br.          300     IN      TXT     "v=spf1 -all"
google.com.br.          2774    IN      NS      ns4.google.com.
google.com.br.          2774    IN      NS      ns2.google.com.
google.com.br.          2774    IN      NS      ns1.google.com.
google.com.br.          2774    IN      NS      ns3.google.com.

AUTHORITY
Servidores que respondem com “autoridade” pelo domínio (os NS)

;; AUTHORITY SECTION:
google.com.br.          3599    IN      NS      ns1.google.com.
google.com.br.          3599    IN      NS      ns4.google.com.
google.com.br.          3599    IN      NS      ns3.google.com.
google.com.br.          3599    IN      NS      ns2.google.com.

ADDITIONAL
Informações auxiliares ou adicionais à pesquisa, no exemplo IPs dos servidores DNS

;; ADDITIONAL SECTION:
ns1.google.com.         172800  IN      AAAA    2001:4860:4802:32::a
ns2.google.com.         172800  IN      AAAA    2001:4860:4802:34::a
ns3.google.com.         172800  IN      AAAA    2001:4860:4802:36::a
ns4.google.com.         172800  IN      AAAA    2001:4860:4802:38::a
ns1.google.com.         172800  IN      A       216.239.32.10
ns2.google.com.         172800  IN      A       216.239.34.10
ns3.google.com.         172800  IN      A       216.239.36.10
ns4.google.com.         172800  IN      A       216.239.38.10

E na ultima sessão entrosamos podemos dizer mais 4 sub sessões:

;; Query time: 1560 msec
;; SERVER: ::1#53(::1)
;; WHEN: ter out 26 09:17:38 -03 2021
;; MSG SIZE  rcvd: 344

- QUERY TIME: vai informar o tempo que levou para realizar a consulta solicitada, quando esse tempo retora 0 é porque a consulta ele pegou do cache.
- SERVER: Qual servidor ele realizou a consulta
- WHEN: dara e hora da consulta + UTC
- MSG SIZE: tamanho do pacote

Um pouquinho de dig para vocês!

Seu DNS recursivo já está pronto, se seu intuito é apenas um DNS recursivo pode pular a parte do autoritativo/reverso, e eu recomendo que você crie uma regra extra no seu nftables (firewall) para fechar a porta 53 externamente, então vou deixar um modelo dessa configuração:
ISSO SÓ DEVER SER FEITO SE SEU DNS FOR APENAS RECURSIVO!

# vim /etc/nftables.conf

Em elements, altere para os seus IPs que terão permissão, o arquivo é quase que auto explicativo. Eu vou aproveitar e criar uma proteção para o SSH e o Zabbix agent

#!/usr/sbin/nft -f
  
flush ruleset

table inet filter {

    set acesso-total4 {
        type ipv4_addr
        flags interval
        elements = { 200.200.200.0/26, 200.200.200.128/29 }
    }
    set acesso-total6 {
        type ipv6_addr
        flags interval
        elements = { 2001:db8:f0da::/48 }
    }
    set acesso-dns4 {
        flags interval
        type ipv4_addr
        elements = { 127.0.0.1, 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12, 100.64.0.0/10, 200.200.200.0/22 }
    }
    set acesso-dns6 {
        flags interval
        type ipv6_addr
        elements = { ::1, 2001:db8::/32 }
    }
    chain input {
        type filter hook input priority 0;

        #ip saddr  @acesso-total4 accept
        #ip6 saddr @acesso-total6 accept

        # Permite acesso SSH na porta 22 (alterada para 60002), a 22 eu fecho só de sacanagem, para aparecer filtrada nos scanners
        ip saddr  @acesso-total4 tcp dport 22 counter accept
        ip6 saddr @acesso-total6 tcp dport 22 counter accept
        ip saddr  @acesso-total4 tcp dport 60002 counter accept
        ip6 saddr @acesso-total6 tcp dport 60002 counter accept
        tcp dport 22 counter drop
        tcp dport 60002 counter drop

        # Permite coleta de dados pelo Zabbix-Agent na porta 10050
        ip saddr  @acesso-total4 tcp dport 10050 counter accept
        ip6 saddr @acesso-total6 tcp dport 10050 counter accept
        tcp dport 10050 counter drop   

        # Permite Acesso DNS na porta 53
        ip saddr  @acesso-dns4 udp dport 53 counter accept
        ip saddr  @acesso-dns4 tcp dport 53 counter accept
        ip6 saddr @acesso-dns6 udp dport 53 counter accept
        ip6 saddr @acesso-dns6 tcp dport 53 counter accept
        udp dport 53 counter drop
        tcp dport 53 counter drop

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

Reinicie os serviços

# systemctl restart nftables fail2ban

Autoritativo

Valorize os domínios.br registrados no https://registro.br/ o memos financia todo o projeto NIC.BR, que na internet brasileira tem uma papel fundament

Configuração do Autoritativo (Master)

Para ficar organizado criaremos alguns diretórios em /var/cache/bind/. Primeiramente a pasta master-aut que se é referencia onde vai ficar nossa configuração do DNS Master autoritativo, e dentro desta pasta uma com o nome do nosso domínio no exemplo remontti.net.br, assim se você tiver vários dominios criamos uma pasta para cada ficando bem organizado.

# mkdir /var/cache/bind/master-aut
# mkdir /var/cache/bind/master-aut/remontti.net.br

Agora vamos criar um em /var/cache/bind/master-aut/remontti.net.br/ para que conter toda a configuração do mesmo, e para ficar objetivo adotei em usar o nome do próprio domínio.hosts ex: remontti.net.br.hosts

# vim /var/cache/bind/master-aut/remontti.net.br/remontti.net.br.hosts

É importante que o serial (2021102601) seja alterado toda vez que for o aruquivo sofrer qualquer alteração, assim o servidor slave saberá que precisa importar novamente as configurações. Ele segue o padrão [ano-mes-dia-sequencial] não que seja uma regra.

$ORIGIN .
$TTL 86400 ; 1 day
remontti.net.br        IN SOA  ns1.remontti.net.br. hostmaster.remontti.net.br. (
                            2023020101 ; serial
                            14400      ; refresh (4 hours)
                            3600       ; retry (1 hour)
                            2419200    ; expire (4 weeks)
                            300        ; minimum (5 minutes)
                            )
 
                        NS      ns1.remontti.net.br.
                        NS      ns2.remontti.net.br.
 
                        A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4

$ORIGIN remontti.net.br.
$TTL 10800   ; 3 hours
 
ns1                     A       45.80.48.2
                        AAAA    2804:f123:bebe:cafe::2
hostmaster              A       45.80.48.2
                        AAAA    2804:f123:bebe:cafe::2

ns2                     A       45.80.48.3
                        AAAA    2804:f123:bebe:cafe::3

www                     A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4

No exemplo estou confiurando apenas alguns subdomínos básicos, como ns1, ns2, www e apontando ele para seus respectivos endereços IPv4 e IPv6, os ipos mais comuns de registros:
- A: Associa um nome a um endereço IPv4.
- AAAA: Associa um nome a um endereço IPv6.
- NS: Name Server. Define quais servidores são os servidores autoritativos do domínio
- SOA: Start-Of-Authority. Detalhes da autoridade do domínio. Descreve o servidor que tem autoridade sobre a zona, além do contato técnico, número serial e outros campos.
- MX: Mail eXchanger. Define os servidores de e-mail.
- PTR: Pointer. Retorna o nome associado a um endereço IP. (reverso)
- CNAME: Canonical NAME. Usados para criar apelidos para o domínio.
- TXT: TeXT. Usados para descrições, comentários, observações de um domínio. Também usado para definir configurações de SPF.

Vamos criar um diretório para gerar nossas keys do DNSSEC.

# mkdir /var/cache/bind/master-aut/remontti.net.br/keys

Entre no diretório:

# cd /var/cache/bind/master-aut/remontti.net.br/keys

Agora vamos a criação das chaves:

# dnssec-keygen -a ECDSAP256SHA256 remontti.net.br

Generating key pair.
Kremontti.net.br.+007+29298

# dnssec-keygen -a ECDSAP256SHA256 -f KSK remontti.net.br

Generating key pair.
Kremontti.net.br.+007+26883

Os comandos acima irão gerar 4 arquivos com extensões .key e .private

├── Kremontti.net.br.+007+26883.key
├── Kremontti.net.br.+007+26883.private
├── Kremontti.net.br.+007+29298.key
└── Kremontti.net.br.+007+29298.private

Altere as permissões de diretórios/arquivos para que o bind consiga criar as assinaturas de forma automaticamente.

# chown bind: /var/cache/bind/master-aut/ -R

Em /etc/bind/named.conf.local "chamaremos" a zona remontti.net.br

# vim /etc/bind/named.conf.local

Adicione ao final do arquivo:

zone "remontti.net.br" {
        type master;
        file "/var/cache/bind/master-aut/remontti.net.br/remontti.net.br.hosts";
        key-directory "/var/cache/bind/master-aut/remontti.net.br/keys/";
        dnssec-policy default;
        inline-signing yes;
        serial-update-method unixtime;
};

Para facilitar farei um atalho da pasta /var/cache/bind/master-aut em /etc/bind/master-aut.

Se você é da turma do mimi você pode subistiruir `type master` por `type primary` e `type slave` por `type secondary` bem como nome das pastas.

# ln -s /var/cache/bind/master-aut /etc/bind/master-aut

Reinicie o serviço.

# systemctl restart bind9

Certifique-se que o bind esta rodando sem erros

# systemctl status bind9

Novos arquivos são gerados em /var/cache/bind/master-aut/remontti.net.br/ .jbk .signed .signed.jnl

└── remontti.net.br
    ├── keys
    │   ├── Kremontti.net.br.+007+26883.key
    │   ├── Kremontti.net.br.+007+26883.private
    │   ├── Kremontti.net.br.+007+29298.key
    │   └── Kremontti.net.br.+007+29298.private
    ├── remontti.net.br.hosts
    ├── remontti.net.br.hosts.jbk
    ├── remontti.net.br.hosts.signed
    └── remontti.net.br.hosts.signed.jnl

Precisaremos descobri nossa keytag e o digest que serão informados no registro.br, para isso rode o comando:

# (d=remontti.net.br; dig @127.0.0.1 +norecurse "$d". DNSKEY | dnssec-dsfromkey -f - "$d" | head -1)

remontti.net.br. IN DS 26883 7 2 F8C2518674B22DB06B1EF38E030F9A238E4FA25D0E2FB80357496E92617FF841

Sendo, keytag:26883 e o digest: F8C2518674B22DB06B1EF38E030F9A238E4FA25D0E2FB80357496E92617FF841

Possíveis bloqueios do fail2ban em caso de configuração errada, ao verificação de um domínios que seu servidor não é autoritativo, ou por um erro na configuração, a consulta será interpretada como recursiva, logo o IP de origem será bloqueado pelo fail2ban, e registrado no arquivo de logs /var/log/named/security.log.

Para evitar fail2ban bloquei seus IPs e pricnipalmente do registro.br, pois muitas pessoas acabam configurando errado seu DNS e na hora de verificar acabam sendo bloqueando. Para evitarmos isso vamos incluir seus IPs bem como os do registrobr na variável ignoreip do fail2ban:

# vim /etc/fail2ban/jail.conf

Localize #ignoreip =, remova o comentário (#) e inclua os prefixo do registrobr 200.160.0.0/20 200.219.148.0/24 2001:12f8:6::/47 2001:12ff::/32 bem como altere 45.80.48.0/22 2804:f123::/32 para IPs do seu AS

ignoreip = 127.0.0.1/8 ::1 200.160.0.0/20 200.219.148.0/24 2001:12f8:6::/47 2001:12ff::/32 45.80.48.0/22 2804:f123::/32

Reinicie o fail2ban

# systemctl restart fail2ban

Configuração do Autoritativo (Slave)

A configuração do slave é bem simples, pois ele irá importar do master todas as configurações.
Para organização vamos seguir o mesmo padrão de diretórios do master

# mkdir /var/cache/bind/slave-aut
# mkdir /var/cache/bind/slave-aut/remontti.net.br

Informamos nossa zona do tipo slave e o IP do nosso servidor master.

# vim /etc/bind/named.conf.local

zone "remontti.net.br" {
        type slave;
        file "/var/cache/bind/slave-aut/remontti.net.br/remontti.net.br.hosts.signed";
        masters { 45.80.48.2; };
        allow-notify { 45.80.48.2; };
};

Alteramos a permissão do diretório para que o bind consiga criar os arquivos.

# chown  bind: /var/cache/bind/slave-aut -R

Mais uma vez farei uma atalho dentro de /etc/bind para facilitar.

# ln -s /var/cache/bind/slave-aut /etc/bind/slave-aut

E reiniciamos o serviço

# systemctl restart bind9

Agora ao verificar o diretório /var/cache/bind/slave-aut/remontti.net.br/ encontraremos nosso arquivo criado automaticamente importado do servidor master.

# ls -lhs /var/cache/bind/slave-aut/remontti.net.br

Validando seu autoritativo no registro.br

Vamos verificar se o servidor responde pelo nosso domínio, acesse: https://registro.br/tecnologia/ferramentas/verificacao-de-dns/ e preecha o formulário com o seu domínio "remontti.net.br" e o IP do seu servidor e clique em pesquisar.
RESULTADO

DOMÍNIO           : remontti.net.br
DNS               : 45.80.48.2
STATUS            : Autoridade sobre o domínio
VERSÃ             : O2021102601
TEMPO DE RESPOSTA : 19.422 ms

Se seu servidor DNS estiver respondedo pelo domínio solicitado uma resposta de sucesso ira apacer: Autoridade sobre o domínio. Repita o mesmo no seu servidor Slave
Agora vamos fazer o mesmo para validade nosso DNSSEC, acesse: https://registro.br/tecnologia/ferramentas/verificacao-de-ds/ e preecha o formulário com o seu domínio "remontti.net.br" e o IP do seu servidor e clique em pesquisar.
RECORDS DS DAS CHAVES ENCONTRADAS

KEY TAG	  ALGORITMO	        DIGEST DS
26883	  RSA-SHA-1-NSEC3	F8C2518674B22DB06B1EF38E030F9A238E4FA25D0E2FB80357496E92617FF841

Se tudo estiver OK, ira receber o resultado da sua KEYTAG e DISGEST bem como encontrado anteriormente.

Seu domínio já está pronto para ser configurado no registro.br, para isso acesse sua conta clique sobre seu domínio e clique em: ALTERAR SERVIDORES DNS, e preecha o formulário, exemplo:

Posso ter mais de um autoritativo no mesmo servidor?

Sim, inclusive o reverso é um autoritavio, vamos falar dele em seguida. Não existe um limite, o limite é seu hardware.
Veja mais um exemplo para um segundo domínio:

# mkdir /var/cache/bind/master-aut/cursodns.com.br
# vim /var/cache/bind/master-aut/cursodns.com.br/cursodns.com.br.hosts

Adicione:

$ORIGIN .
$TTL 86400 ; 1 day
cursodns.com.br           IN SOA  ns1.cursodns.com.br. hostmaster.cursodns.com.br. (
                            2023020101 ; serial
                            14400      ; refresh (4 hours)
                            3600       ; retry   (1 hour)
                            2419200    ; expire  (4 weeks)
                            300        ; minimum (5 minutes)
                            )
 
                        NS      ns1.cursodns.com.br.
                        NS      ns2.cursodns.com.br.
 
                        A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4
                        MX      10 mail.cursodns.com.br.
                        TXT     "v=spf1 a mx -all"
                        SPF     "v=spf1 a mx -all"

$ORIGIN cursodns.com.br.
_dmarc                  TXT "v=DMARC1; p=none"
_domainkey              TXT "t=y; o=~;"

$ORIGIN _domainkey.cursodns.com.br.
mail                    TXT "v=DKIM1; k=rsa; p=6B4EDqoi5l64qyxnenKx56IOIjPAnj350mq"

$ORIGIN cursodns.com.br.
$TTL 10800   ; 3 hours
 
ns1                     A       45.80.48.2
                        AAAA    2804:f123:bebe:cafe::2
hostmaster              A       45.80.48.2
                        AAAA    2804:f123:bebe:cafe::2

ns2                     A       45.80.48.3
                        AAAA    2804:f123:bebe:cafe::3

www                     A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4
ftp                     A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4
imap                    A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4
pop                     A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4
smtp                    A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4
mail                    A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4

Vamos criar um diretório para gerar nossas keys do DNSSEC.

# mkdir /var/cache/bind/master-aut/cursodns.com.br/keys

Entre no diretório:

# cd /var/cache/bind/master-aut/cursodns.com.br/keys

Agora vamos a criação das chaves:

# dnssec-keygen -a ECDSAP256SHA256 cursodns.com.br

Generating key pair.
Kcursodns.com.br.+007+00558

# dnssec-keygen -a ECDSAP256SHA256 -f KSK cursodns.com.br

Generating key pair.
Kcursodns.com.br.+007+46491

Altere as permissões de diretórios/arquivos para que o bind consiga criar as assinaturas de forma automaticamente.

# chown bind: /var/cache/bind/master-aut/ -R

Adicione a zona cursodns.com.br em named.conf.local

# vim /etc/bind/named.conf.local

Adicione ao final do arquivo:

zone "cursodns.com.br" {
        type master;
        file "/var/cache/bind/master-aut/cursodns.com.br/cursodns.com.br.hosts";
        key-directory "/var/cache/bind/master-aut/cursodns.com.br/keys/";
        dnssec-policy default;
        inline-signing yes;
        serial-update-method unixtime;
};

Se desejar validar seu arquivo antes de reiniciar o serviço:

# cd /var/cache/bind/master-aut/
# named-checkzone cursodns.com.br cursodns.com.br.hosts

Tudo ok, altere as permissões para não ter erro, e reinicie o bind:

# chown  bind: /var/cache/bind/master-aut -R
# systemctl restart bind9

Para o Slave

# mkdir /var/cache/bind/slave-aut/cursodns.com.br
# vim /etc/bind/named.conf.local

zone "cursodns.com.br" {
        type slave;
        file "/var/cache/bind/slave-aut/cursodns.com.br/cursodns.com.br.hosts.signed";
        masters { 45.80.48.2; };
        allow-notify { 45.80.48.2; };
};

# chown  bind: /var/cache/bind/slave-aut -R
# systemctl restart bind9

Posso ter domínios "fakes"?
Sim, basta criar uma zona. Mas juridicamente você pode ter dor de cabeça. Recomendo a leitura do DNS Response Policy Zone (RPZ) para que retornem resultados modificados em grande escala de uma foma mais eficaz. Alguns administradores podem usar o DNS RPZ para impedir acessos indesejados, normalmente é usado em empresas para bloquear por exemplo hosts infectados por malwares, sites pornográficos, entre outros casos, bloqueando a resolução de nomes. Segue um modelo simples e rápido para montar seu RPZ.

# vim /var/cache/bind/master-aut/cursodns.com.br/cursodns.com.br.hosts

Adicione mais uma entrada em para um novo subdominio "umbrella" apontando para um servidor, esse pode está rodando um serviço web qual pode ter uma tela com um aviso.

//...
umbrella                        A       45.80.48.5
                                AAAA    2804:f123:bebe:cafe::5
//...

Adicione uma nova zona chamada rpz.zone

# vim /etc/bind/named.conf.local

zone "rpz.zone" {
    type master;
    file "/var/cache/bind/rpz/db.rpz.zone";
    allow-query { none; };
};

# vim /etc/bind/named.conf.options

Dentro de options { ... } adcione:

options {
//...
    response-policy {
      zone "rpz.zone" policy CNAME umbrella.cursodns.com.br;
    };
//...

};
Criaremos o diretório rpz, bem como o arquivos de hosts

# mkdir /var/cache/bind/rpz/
# ln -s /var/cache/bind/rpz/ /etc/bind/rpz
# vim /var/cache/bind/rpz/db.rpz.zone

$TTL 1H
@       IN      SOA LOCALHOST. umbrella.cursodns.com.br. (
                2023020101      ; Serial  
                1h              ; Refresh
                15m             ; Retry
                30d             ; Expire 
                2h              ; Negative Cache TTL
        )
        NS  umbrella.cursodns.com.br.
 
xvideos.com     IN CNAME .
*.xvideos       IN CNAME .
redtube.com     IN CNAME .
*.redtube.com   IN CNAME .
pornhub.com     IN CNAME .
*.pornhub.com   IN CNAME .

Sendo que para cada dominio que você deseja apontar para resolver o mesmo IP do nosso umbrella.cursodns.com.br siga este padrão:

domino.com     IN CNAME .
*.domino.com       IN CNAME .

Assim qualquer subidominio (*).domino.com seja traduzido sempre para o mesmo IP.

Altere as permissões e reinicie o serviço

# chown bind: /var/cache/bind/rpz/ -R
# systemctl restart bind9

Agora faça um teste para ver o que seu servidor ira traduzir:

# dig xvideos.com @localhost

; <<>> DiG 9.16.15-Debian <<>> xvideos.com @localhost
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 1040
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 2

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: a060f744b32f2a4f01000000617842817ffcfff0a6b99fff (good)
;; QUESTION SECTION:
;xvideos.com.                   IN      A

;; ANSWER SECTION:
xvideos.com.            5       IN      CNAME   umbrella.cursodns.com.br.
umbrella.cursodns.com.br. 10800 IN      A       45.80.48.5

;; ADDITIONAL SECTION:
rpz.zone.               1       IN      SOA     LOCALHOST. umbrella.cursodns.com.br. 2020062400 3600 900 2592000 7200

;; Query time: 0 msec
;; SERVER: ::1#53(::1)
;; WHEN: ter out 26 15:01:37 -03 2021
;; MSG SIZE  rcvd: 175

# dig qqrcoisa.xvideos.com @localhost
# dig pornhub.com @localhost
# dig www.pornhub.com @localhost
# dig redtube.com @localhost

Uma boa list de hosts você pode encontrar aqui.
Não esquece de mandar meu presente de natal!

Reverso DNS Master - Para prefixos maiores ou igual a /24.

Obs: Para fazer a Delegações de DNS reverso do seu bloco, é importante que você já tenha configurado no registro.br seu DNS autoritativo.

Para ficar organizado criaremos a pasta master-rev para salvar todos nossos arquivos

# mkdir /var/cache/bind/master-rev

Para nosso cenários vou usar os prefixos 45.80.48.0/22 e 2804:f123::/32. O bloco 45.80.48.0/22 será necessário quebrar em 4 arquivos uma para cada prefixo /24 qual teremos nossos 1024 nome de hosts (IPs).

Lembra que anteriormente comentei que o reverso não passa de um domínio autoritativo? Então é isso mesmo, a forma de configuração é a mesma, porem já temos o nosso domínios para IPv4 x.x.x.in-addr.arpa e x.x.x.x.x.x.x.x.ip6.arpa para IPv6.

Primeiro arquivo /24 farei com o nome de 45.80.48.rev, poderia ser qualquer nome, mas assim fica bem sugestivo.

# vim /var/cache/bind/master-rev/45.80.48.rev

Preste atenção em 48.80.45.in-addr.arpa. essa linha ela deve ser alterada com o inverso do seu IP, de trás para frente.
Outra coisa importante é o serial (2021102601) ele está presente em todos os arquivos e deve ser alterado toda vez que for alterado. Ele segue o padrão [ano-mes-dia-sequencial]. É fundamental altera-lo para que o servidor slave copie sempre que tiver uma alteração.

Neste arquivo darei nomes personalizados apenas para o ns1 e ns2 o resto usarei o GENERATE para gerar de forma automatica todos os mais de mil nomes, sengindo o padrão 45-80-50-x.remontti.net.br.

$ORIGIN .
$TTL 86400      ; 1 day
48.80.45.in-addr.arpa IN SOA ns1.remontti.net.br. hostmaster.remontti.net.br. (
                    2023020101 ; serial
                    14400      ; refresh (4 hours)
                    3600       ; retry (1 hour)
                    2419200    ; expire (4 weeks)
                    300        ; minimum (5 minutes)
                    )
                NS      ns1.remontti.net.br.
                NS      ns2.remontti.net.br.

$ORIGIN 48.80.45.in-addr.arpa.
2         PTR     ns1.remontti.net.br.
3         PTR     ns2.remontti.net.br.

$ORIGIN 48.80.45.in-addr.arpa.
$GENERATE 0-1     $  PTR  45-80-48-$.remontti.net.br.
$GENERATE 4-255   $  PTR  45-80-48-$.remontti.net.br.

Proximo /24

# vim /var/cache/bind/master-rev/45.80.49.rev

$ORIGIN .
$TTL 86400      ; 1 day
49.80.45.in-addr.arpa IN SOA ns1.remontti.net.br. hostmaster.remontti.net.br. (
                    2023020101 ; serial
                    14400      ; refresh (4 hours)
                    3600       ; retry (1 hour)
                    2419200    ; expire (4 weeks)
                    300        ; minimum (5 minutes)
                    )
                NS      ns1.remontti.net.br.
                NS      ns2.remontti.net.br.

$ORIGIN 49.80.45.in-addr.arpa.
$GENERATE 0-255 $ PTR 45-80-49-$.remontti.net.br.

# vim /var/cache/bind/master-rev/45.80.50.rev

$ORIGIN .
$TTL 86400      ; 1 day
50.80.45.in-addr.arpa IN SOA ns1.remontti.net.br. hostmaster.remontti.net.br. (
                    2023020101 ; serial
                    14400      ; refresh (4 hours)
                    3600       ; retry (1 hour)
                    2419200    ; expire (4 weeks)
                    300        ; minimum (5 minutes)
                    )
                NS      ns1.remontti.net.br.
                NS      ns2.remontti.net.br.

$ORIGIN 50.80.45.in-addr.arpa.
$GENERATE 0-255 $ PTR 45-80-50-$.remontti.net.br.

# vim /var/cache/bind/master-rev/45.80.51.rev

$ORIGIN .
$TTL 86400      ; 1 day
51.80.45.in-addr.arpa IN SOA ns1.remontti.net.br. hostmaster.remontti.net.br. (
                    2023020101 ; serial
                    14400      ; refresh (4 hours)
                    3600       ; retry (1 hour)
                    2419200    ; expire (4 weeks)
                    300        ; minimum (5 minutes)
                    )
                NS      ns1.remontti.net.br.
                NS      ns2.remontti.net.br.

$ORIGIN 51.80.45.in-addr.arpa.
$GENERATE 0-255 $ PTR 45-80-51-$.remontti.net.br.

# vim /var/cache/bind/master-rev/2804.f123.rev

Antenção no 3.2.1.f.4.0.8.2.ip6.arpa o site http://rdns6.com/hostRecord pode ser bem útil para gerar seus PTRs.

$ORIGIN .
$TTL 3600       ; 1 hour
3.2.1.f.4.0.8.2.ip6.arpa IN SOA ns1.remontti.net.br.3.2.1.f.4.0.8.2.ip6.arpa. hostmaster.remontti.net.br.3.2.1.f.4.0.8.2.ip6.arpa. (
                    2023020101 ; serial
                    14400      ; refresh (4 hours)
                    3600       ; retry (1 hour)
                    2419200    ; expire (4 weeks)
                    300        ; minimum (5 minutes)
                    )
            NS      ns1.remontti.net.br.
            NS      ns2.remontti.net.br.

2.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.e.f.a.c.e.b.e.b.3.2.1.f.4.0.8.2.ip6.arpa.   PTR     ns1.remontti.net.br.
3.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.e.f.a.c.e.b.e.b.3.2.1.f.4.0.8.2.ip6.arpa.   PTR     ns2.remontti.net.br.

Ajustamos as permissões:

# chown bind: /var/cache/bind/master-rev/ -R

Criamos uma atalho para facilitar:

# ln -s /var/cache/bind/master-rev/ /etc/bind/master-rev

Agora nós precisamos informar nossas zonas reversas no named.conf.local, como estamos configurando nosso servidor master essas zonas serão do tipo (type) master.

# vim /etc/bind/named.conf.local

Adicione ao final do arquivo:

zone "48.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.48.rev";
};
 
zone "49.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.49.rev";
};
 
zone "50.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.50.rev";
};
 
zone "51.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.51.rev";
};

zone "3.2.1.f.4.0.8.2.ip6.arpa" {
        type master;
        file "/var/cache/bind/master-rev/2804.f123.rev";
};

Reinicie o serviço e verifique se o mesmo subiu sem erros.

# systemctl restart bind9
# systemctl status bind9

Checando se nosso IP reverso está resolvendo os nomes setados, com o comando `dig -x IP @localhost +short`

# dig -x 45.80.48.0 @localhost +short
45-80-48-0.remontti.net.br.

# dig -x 45.80.48.255 @localhost +short
45-80-48-255.remontti.net.br.

# dig -x 45.80.48.2 @localhost +short
ns1.remontti.net.br.

# dig -x 45.80.48.3 @localhost +short
ns2.remontti.net.br.

# dig -x 45.80.49.0 @localhost +short
45-80-49-0.remontti.net.br.

# dig -x 45.80.49.255 @localhost +short
45-80-49-255.remontti.net.br.

# dig -x 45.80.50.0 @localhost +short
45-80-50-0.remontti.net.br.

# dig -x 45.80.50.255 @localhost +short
45-80-50-255.remontti.net.br.
 
# dig -x 45.80.51.0 @localhost +short
45-80-51-0.remontti.net.br.

# dig -x 45.80.51.255 @localhost +short
45-80-51-255.remontti.net.br.

# dig -x 2804:f123:bebe:cafe::2 @localhost +short
ns1.remontti.net.br.

# dig -x 2804:f123:bebe:cafe::3 @localhost +short
ns2.remontti.net.br.

Como criamos nomes aos 1024 hosts/IPs (x-x-x-x.remontti.net.br) será necessário apontar cada nome desses no arquivo de autoritativo do domínio remontti.net.br para cada nome um IP. Para isso vamos voltar as configurações do domínio autoritativo que já configurado. Lembre-se de alterar o serial!

# host 45-80-50-0.remontti.net.br.

Host 45-80-50-0.remontti.net.br. not found: 3(NXDOMAIN)
Só para relembrar: NXDOMAIN: Significa que o domínio pesquisado não existe.

Para resolver isso então vamos criar todos nosso nomes.
vamos adicionar ao final do arquivo /var/cache/bind/master-aut/remontti.net.br/remontti.net.br.hosts

$ORIGIN remontti.net.br.
$GENERATE 0-1    45-80-48-$   A   45.80.48.$
$GENERATE 4-255  45-80-48-$   A   45.80.48.$
$GENERATE 0-255  45-80-49-$   A   45.80.49.$
$GENERATE 0-255  45-80-50-$   A   45.80.50.$
$GENERATE 0-255  45-80-51-$   A   45.80.51.$

# vim /var/cache/bind/master-aut/remontti.net.br/remontti.net.br.hosts

Ficando:

$ORIGIN .
$TTL 86400 ; 1 day
remontti.net.br        IN SOA  ns1.remontti.net.br. hostmaster.remontti.net.br. (
                            2023020101 ; serial
                            14400      ; refresh (4 hours)
                            3600       ; retry (1 hour)
                            2419200    ; expire (4 weeks)
                            300        ; minimum (5 minutes)
                            )
 
                        NS      ns1.remontti.net.br.
                        NS      ns2.remontti.net.br.
 
                        A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4

$ORIGIN remontti.net.br.
$TTL 10800   ; 3 hours
 
ns1                     A       45.80.48.2
                        AAAA    2804:f123:bebe:cafe::2
hostmaster              A       45.80.48.2
                        AAAA    2804:f123:bebe:cafe::2
ns2                     A       45.80.48.3
                        AAAA    2804:f123:bebe:cafe::3
www                     A       45.80.48.4
                        AAAA    2804:f123:bebe:cafe::4

$ORIGIN remontti.net.br.
$GENERATE 0-1    45-80-48-$   A   45.80.48.$
$GENERATE 4-255  45-80-48-$   A   45.80.48.$
$GENERATE 0-255  45-80-49-$   A   45.80.49.$
$GENERATE 0-255  45-80-50-$   A   45.80.50.$
$GENERATE 0-255  45-80-51-$   A   45.80.51.$

Autoritativo ajustado, reinicie o serviço e verifique se o mesmo subiu sem erros.

# systemctl restart bind9
# systemctl status bind9

Agora ao consultar nosso nomes temos uma resposta dizendo qual nosso endereço ip

# host 45-80-48-0.remontti.net.br.
45-80-48-0.remontti.net.br has address 45.80.48.0
 
# host 45-80-49-0.remontti.net.br.
45-80-49-0.remontti.net.br has address 45.80.49.0

# host 45-80-50-0.remontti.net.br.
45-80-50-0.remontti.net.br has address 45.80.50.0

# host 45-80-51-0.remontti.net.br.
45-80-51-0.remontti.net.br has address 45.80.51.0

# host ns1.remontti.net.br.
ns1.remontti.net.br has address 45.80.48.2
ns1.remontti.net.br has IPv6 address 2804:f123:bebe:cafe::2

# host ns2.remontti.net.br.
ns2.remontti.net.br has address 45.80.48.3
ns2.remontti.net.br has IPv6 address 2804:f123:bebe:cafe::3

Para o servidor Slave

Crie o diretório onde irão ficar os arquivos e dê permissão

# mkdir /var/cache/bind/slave-rev
# chown bind: /var/cache/bind/slave-rev -R

Em seguiga crie as zonas no arquivo named.conf.local, que serão do tipo (slave) e apontaremos o IP do DNS Master para que o servidor slave faça a transferência.

# vim /etc/bind/named.conf.local

Adicione ao final:

zone "48.80.45.in-addr.arpa" {
        type slave;
        file "/var/cache/bind/slave-rev/45.80.48.rev";
        masters { 45.80.48.2; };
        allow-notify { 45.80.48.2; };
};
 
zone "49.80.45.in-addr.arpa" {
        type slave;
        file "/var/cache/bind/slave-rev/45.80.49.rev";
        masters { 45.80.48.2; };
        allow-notify { 45.80.48.2; };
};
 
zone "50.80.45.in-addr.arpa" {
        type slave;
        file "/var/cache/bind/slave-rev/45.80.50.rev";
        masters { 45.80.48.2; };
        allow-notify { 45.80.48.2; };
};
 
zone "51.80.45.in-addr.arpa" {
        type slave;
        file "/var/cache/bind/slave-rev/45.80.51.rev";
        masters { 45.80.48.2; };
        allow-notify { 45.80.48.2; };
};

zone "3.2.1.f.4.0.8.2.ip6.arpa" {
        type slave;
        file "/var/cache/bind/slave-rev/2804.f123.rev";
        masters { 45.80.48.2; };
        allow-notify { 45.80.48.2; };
};

Crio o atalho, reinico o serviço e verifico se o mesmo subiu sem erros, em seguida olho se os arquivos foram criando nas pasta.

# ln -s /var/cache/bind/slave-rev /etc/bind/slave-rev
# systemctl restart bind9
# systemctl status bind9
# ls -lh /var/cache/bind/slave-rev/ 

Validando seu reverso no registro.br https://registro.br/tecnologia/ferramentas/verificacao-de-dns/
Vamos verificar pelos domínos .arpa

48.80.45.in-addr.arpa
49.80.45.in-addr.arpa
50.80.45.in-addr.arpa
51.80.45.in-addr.arpa
3.2.1.f.4.0.8.2.ip6.arpa

RESULTADOS

DOMÍNIO            : 48.80.45.in-addr.arpa
DNS                : 45.80.48.2
STATUS             : Autoridade sobre o domínio
VERSÃ              : O2021102602
TEMPO DE RESPOSTA  : 23.990 ms

DOMÍNIO            : 49.80.45.in-addr.arpa
DNS                : 45.80.48.2
STATUS             : Autoridade sobre o domínio
VERSÃ              : O2021102602
TEMPO DE RESPOSTA  : 23.990 ms

DOMÍNIO            : 50.80.45.in-addr.arpa
DNS                : 45.80.48.2
STATUS             : Autoridade sobre o domínio
VERSÃ              : O2021102602
TEMPO DE RESPOSTA  : 23.990 ms

DOMÍNIO            : 51.80.45.in-addr.arpa
DNS                : 45.80.48.2
STATUS             : Autoridade sobre o domínio
VERSÃ              : O2021102602
TEMPO DE RESPOSTA  : 23.990 ms

DOMÍNIO            : 3.2.1.f.4.0.8.2.ip6.arpa
DNS                : 45.80.48.2
STATUS             : Autoridade sobre o domínio
VERSÃ              : O2021102602
TEMPO DE RESPOSTA  : 23.990 ms

Se tudo estiver certo você terá Autoridade sobre o domínio, repita o mesmo no seu para o IP do servidor Slave.

Seu reverso está pronto para ser configurado no registro.br, acesse sua conta clique em NUMERAÇÃO em seguira sobre seu prefixo exemplo 45.80.48.0/22, clique no "quadro azul" e clique em Configurar DNS, preencha o formulário Delegação DNS - 45.80.48.0/22 informado o Servidor 1: ns1.remontti.net.br e Servidor 2: ns2.remontti.net.br. Lembrando que o DNS do autoritativo "remontti.net.br" deve estar com os subdominios ns1 e ns2 apontando para o IP do seu servidor DNS, e o mesmo já deve ter propagado, se você tem acabou de alterar os DNS do remontti.net.br aguarde um tempo (até 24h) para fazer a configuração do reverso.

Dúvida frequente:
- Posso ter reversos de diferentes blocos usando o mesmo domínio autoritativo?
Sim, como também pode para outros domínios, inclusive mesclados.

- É possível configurar o DNSSEC para os reversos? Sim basta seguir o mesmo padrão que usamos no exemplo com nosso propío domínio, lembrado que "não existe reverso" tudo é um dominio autoritativo que já existe chamado de xxxxxxxx.in-addr.arpa e xxxxxxx.ip6.arpa, para configurar no registro br é muito simples, basta você realizar a configuração do DNSSEC em cima de cada /24 seu e ir no painel do registro e clicar em DNSSEC e salvar, ele ira identificar sua configuração.

Um ótimo site para verificar seu DNSSEC é o https://dnsviz.net/

Como configurar o reverso para prefixos menores que /24

Vamos supor que você dono de um /22 e vai repassar um prefixo /28 para um provedor sem AS ou uma empresa que é seu cliente, e o mesmo deseja ter seu reverso respondendo em seus servidores DNS (RFC2317).

Primeiramente faça a delegação no registro.br do /28 para o CNPJ/Domínios do de seu cliente, acesse sua conta clique em NUMERAÇÃO em seguira sobre seu prefixo exemplo 45.80.48.0/22, clique no "quadro azul" e clique em Expandir até chegar no prefixo /28, clieque sobre o quadro do prefixo desejado e em seguida em Configurar designação e preecha o formulário com o CNPJ/Domínios do seu cliente, se o mesmo não possuir solicite que faça seu cadastro.

Se ficar em dúvidas recomendo que assista: https://www.youtube.com/watch?v=VIa1dHtmQ4U DNS Reverso (~20min fala sobre isso)
No exemplo vamos supor que o bloco seja o 45.80.49.64/28, como o mesmo fica no arquivo 45.80.49.rev vamos edita-lo.

# vim /var/cache/bind/master-rev/45.80.49.rev

Iremos quebrar nosso GENERETE para pular os IPs finais 64 a 79, e vamos apontar ele para os DNS do cliente, logo é claro que ele precisa ter um domínio já configurado, e nesse DNS ele apontar exemplo ns1 e ns2 para o IP do servidor que ele estará fazendo a configuração. Explico já já como faz o lado dele.

$ORIGIN .
$TTL 86400      ; 1 day
51.80.45.in-addr.arpa IN SOA ns1.remontti.net.br. hostmaster.remontti.net.br. (
                    2023020101 ; serial
                    14400      ; refresh (4 hours)
                    3600       ; retry (1 hour)
                    2419200    ; expire (4 weeks)
                    300        ; minimum (5 minutes)
                    )
                NS      ns1.remontti.net.br.
                NS      ns2.remontti.net.br.

$ORIGIN 49.80.45.in-addr.arpa.
$GENERATE 0-63 $ PTR 45-80-51-$.remontti.net.br.

; Cliente delegado
;  <<64-79>> /28
; Aponte para os DNS do Servidor do José 
64/28     NS     ns1.provedordojose.com.br. 
64/28     NS     ns2.provedordojose.com.br. 
; 
64      CNAME    64.45/28.49.80.45.in-addr.arpa. 
65      CNAME    65.45/28.49.80.45.in-addr.arpa. 
66      CNAME    66.45/28.49.80.45.in-addr.arpa. 
67      CNAME    67.45/28.49.80.45.in-addr.arpa. 
68      CNAME    68.45/28.49.80.45.in-addr.arpa. 
69      CNAME    69.45/28.49.80.45.in-addr.arpa. 
70      CNAME    70.45/28.49.80.45.in-addr.arpa. 
71      CNAME    71.45/28.49.80.45.in-addr.arpa. 
72      CNAME    72.45/28.49.80.45.in-addr.arpa. 
73      CNAME    73.45/28.49.80.45.in-addr.arpa. 
74      CNAME    74.45/28.49.80.45.in-addr.arpa. 
75      CNAME    75.45/28.49.80.45.in-addr.arpa. 
76      CNAME    76.45/28.49.80.45.in-addr.arpa. 
77      CNAME    77.45/28.49.80.45.in-addr.arpa. 
78      CNAME    78.45/28.49.80.45.in-addr.arpa. 
79      CNAME    79.45/28.49.80.45.in-addr.arpa.

$ORIGIN 51.80.45.in-addr.arpa.
$GENERATE 80-255 $ PTR 45-80-51-$.remontti.net.br.

Reinicie o serviço e verifique o mesmo

# systemctl restart bind9
# systemctl status bind9

Lado do "provedor do Jose"

Como estamos falando de um outro provedor, é quase certo que ele fará seu DNS: Recursivo, autoritativo e reverso. Então faça a instalação do bind e todos os procedimentos das configurações de recursivo e autoritativo sobre o domínio “provedordojose.com.br”, porém a configuração do reverso irá mudar um pouco, ficando:

Autoritativo

# vim /var/cache/bind/master-aut/provedordojose.com/provedordojose.com.br.hosts

$ORIGIN .
$TTL 86400 ; 1 day
provedordojose.com.br        IN SOA  ns1.provedordojose.com.br. hostmaster.provedordojose.com.br. (
                            2023020101 ; serial
                            14400      ; refresh (4 hours)
                            3600       ; retry (1 hour)
                            2419200    ; expire (4 weeks)
                            300        ; minimum (5 minutes)
                            )

                        NS      ns1.provedordojose.com.br.
                        NS      ns2.provedordojose.com.br.

                        A       45.80.49.67

$ORIGIN provedordojose.com.br.
$TTL 10800   ; 3 hours

ns1                     A       45.80.49.66
hostmaster              A       45.80.49.66

ns2                     A       45.80.49.67

www                     A       45.80.49.67

$ORIGIN provedordojose.com.br.
$GENERATE 64-65  45-80-49-$    A   45.80.49.$

$ORIGIN provedordojose.com.br.
$GENERATE 68-79  45-80-49-$    A   45.80.49.$

Reverso

# vim /var/cache/bind/master-rev/45.80.49.64-79.rev

$TTL 1h
@               IN      SOA     ns1.provedordojose.com.br. root.provedordojose.com.br. (
                    2020050101 ; serial
                    10800      ; refresh (3 hours)
                    3600       ; retry (1 hour)
                    2419200    ; expire (4 weeks)
                    300        ; minimum (5 minutes)
                    )

        IN      NS      ns1.provedordojose.com.br.
        IN      NS      ns2.provedordojose.com.br.

$ORIGIN 64/28.49.80.45.in-addr.arpa.
64      IN      PTR     45-80-49-64.provedordojose.com.br.
65      IN      PTR     45-80-49-65.provedordojose.com.br.
66      IN      PTR     ns1.provedordojose.com.br.
67      IN      PTR     ns2.provedordojose.com.br.
68      IN      PTR     45-80-49-68.provedordojose.com.br.
69      IN      PTR     45-80-49-69.provedordojose.com.br.
70      IN      PTR     45-80-49-70.provedordojose.com.br.
71      IN      PTR     45-80-49-71.provedordojose.com.br.
72      IN      PTR     45-80-49-72.provedordojose.com.br.
73      IN      PTR     45-80-49-73.provedordojose.com.br.
74      IN      PTR     45-80-49-74.provedordojose.com.br.
75      IN      PTR     45-80-49-75.provedordojose.com.br.
76      IN      PTR     45-80-49-76.provedordojose.com.br.
77      IN      PTR     45-80-49-77.provedordojose.com.br.
78      IN      PTR     45-80-49-78.provedordojose.com.br.
79      IN      PTR     45-80-49-79.provedordojose.com.br.

# vim /etc/bind/named.conf.local

zone "provedordojose.com.br" {
        type master;
        file "/var/cache/bind/master-aut/provedordojose.com.br/provedordojose.com.br.hosts";
        key-directory "/var/cache/bind/master-aut/rprovedordojose.com.br/keys/";
        dnssec-policy default;
        inline-signing yes;
        serial-update-method unixtime;
};

zone "64/28.49.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.49.64-79.rev";
};

Reinicie o serviço

# systemctl restart bind9
# systemctl status bind9

Situação de reverso para cliente final sem ele ter servidor de DNS

Meu cliente quer que eu aponto os nomes dos IPs reverso para o seu domínio, posso?
Sim, pode! Em muitos casos de clientes corporativos que tem seu próprio servidor de e-mail é possível que o mesmo peça para fazer isso. Ex:

# vim /var/cache/bind/master-rev/45.80.49.rev

$ORIGIN .
$TTL 86400      ; 1 day
49.80.45.in-addr.arpa IN SOA ns1.remontti.net.br. hostmaster.remontti.net.br. (
                    2023020101 ; serial
                    14400      ; refresh (4 hours)
                    3600       ; retry (1 hour)
                    2419200    ; expire (4 weeks)
                    300        ; minimum (5 minutes)
                    )
                NS      ns1.remontti.net.br.
                NS      ns2.remontti.net.br.

$ORIGIN 49.80.45.in-addr.arpa.
$GENERATE 0-63 $ PTR 45-80-49-$.remontti.net.br.

$ORIGIN 49.80.45.in-addr.arpa.
64      PTR     45-80-49-64.provedordojose.com.br.
65      PTR     45-80-49-65.provedordojose.com.br.
66      PTR     ns1.provedordojose.com.br.
67      PTR     ns2.provedordojose.com.br.
68      PTR     mail.provedordojose.com.br.
69      PTR     45-80-49-69.provedordojose.com.br.
70      PTR     45-80-49-70.provedordojose.com.br.
71      PTR     45-80-49-71.provedordojose.com.br.
72      PTR     45-80-49-72.provedordojose.com.br.
73      PTR     45-80-49-73.provedordojose.com.br.
74      PTR     45-80-49-74.provedordojose.com.br.
75      PTR     45-80-49-75.provedordojose.com.br.
76      PTR     45-80-49-76.provedordojose.com.br.
77      PTR     45-80-49-77.provedordojose.com.br.
78      PTR     45-80-49-78.provedordojose.com.br.
79      PTR     45-80-49-79.provedordojose.com.br.

$ORIGIN 49.80.45.in-addr.arpa.
$GENERATE 80-199 $ PTR 45-80-49-$.remontti.net.br.

$ORIGIN 49.80.45.in-addr.arpa.
200     PTR     mail.empresa.com.br.
201     PTR     mail.minhaempresa.com.br.
202     PTR     mail.algumaempresa.com.br.
203     PTR     www.algumchato.com.br.
204     PTR     maischatoainda.com.br.

$ORIGIN 49.80.45.in-addr.arpa.
$GENERATE 205-255 $ PTR 45-80-49-$.remontti.net.br.

Reinicie os serviços

# systemctl restart bind9
# systemctl status bind9

Mais um pouco de DNS!

Posso configurar DNS reverso de IPs privados?
Sim pode, ajustes no named.conf.default-zones e zones.rfc1918
Remova as linhas dos IPs privados que deseja configurar.

Posso configurar DNS reverso de outro AS?
Sim. Basta configurar! (Conheço provedores pequenos que ambos tem 1 servidor DNS cada e um é o backup do outro)

Estatísticas do DNS

Estatística web/http (statistics-channels)
Para ativar edite o /etc/bind/named.conf

# vim /etc/bind/named.conf

Adicione antes dos include, sendo que 45.80.48.2 é o IP público do DNS e 45.80.48.100 e 45.80.48.101 (Só aceita /32) são os IPs que poderão acessar no navegaro a porta 58053 para visualizar as informações. Porém perceba que também deixou um inet só para o IP de loopback (127.0.0.1 ) a ideiá aqui é que só o zabbix-agente acesse, eu particularmente não deixou o outro inet sendo ouvido, se deseja comente ele com //

statistics-channels {
       inet 127.0.0.1  port 58053 allow { 127.0.0.1; ::1; };
       inet 45.80.48.2  port 58053 allow { 45.80.48.100; 45.80.48.101; };
};

Para surtir efeito reinicie o serviço

# systemctl restart bind9

Agora acesse http://IP_DNS:58053/

Usaremos a seguir este método para coletar informações para o zabbix.

Outra forma é as estatística em arquivo (statistics-file), você pode definir um local especifico para gerar seu arquivo com as estatística, caso não especificado o mesmo é gerado em /var/cache/bind/named.stats

# vim /etc/bind/named.conf.options

Adicione dentro de options { … }

options {
//…
//…
    statistics-file "/var/log/named/named.stats";
//…
//…
};

Como sempre, em toda alteração reiniciamos o serviço

# systemctl restart bind9

Porém para gere o arquivo de estatísticas é necessário o comando, e toda vez que deseja atualizar precisa executar o comando.

# rndc stats

Exibe os dados do arquivo

# cat /var/log/named/named.stats
ou
# cat /var/cache/bind/named.stats

Caso queira ver oque esta em cache pode usar o comando:

# rndc dumpdb -cache

Ira gerar um arquivo named_dump.db em /var/cache/bind/

# cat /var/cache/bind/ | more
# cat /var/cache/bind/ | grep google

Criando Backup

Basta salvar os diretórios /etc/bind/* /var/cache/bind/* /usr/share/dns/* Gerar um arquivo de backup

# tar -czpf ns1.tar.gz /etc/bind/* /var/cache/bind/* /usr/share/dns/*

Extrair arquivo de backup

# tar vxf ns1.tar.gz

Recomendo a leitura do tutorial: Criando backups de forma simples e enviando para o Telegram ou servidor via SSH

Coletando dados dos bind e fail2ban para Zabbix 6 LTS

Se você ainda não tem um zabbix server aqui tem um belo tutorial:
Instalação do Zabbix 6 LTS + NGINX + PostgreSQL + Debian 11
Instalação do Grafana no Debian 11 Bullseye

No nosso servidor DNS vamos precisar apenas do zabbix-agent, vamos adiciona o repositório do zabbix LTS para Debian 11 e em seguina intala-lo.

# cd /tmp
# apt install wget
# cd /tmp/
# wget https://repo.zabbix.com/zabbix/6.0/debian/pool/main/z/zabbix-release/zabbix-release_6.0-5+debian12_all.deb
# apt install ./zabbix-release_6.0-5+debian12_all.deb
# apt update; apt upgrade -y
# apt install zabbix-agent
# systemctl enable zabbix-agent

Em seguida vamos precisar informar o IP do zabbix server:

# vim /etc/zabbix/zabbix_agentd.conf

Localize e altere:

Server=45.80.48.10 #IP Zabbix Server
ServerActive=45.80.48.10 #IP Zabbix Server
Hostname=ns1 #Nome exato cadastrado no Zabbix server

Reinicie o serviço do zabbix agent

# systemctl restart zabbix-agent

Não esqueça de ajustar statistics-channels named.conf:

statistics-channels {
  inet 127.0.0.1 port 58053 allow { 127.0.0.1; };
};

Vou usar o projeto Zabbix-Bind9-Statistics-Collection compartilhado no meu gituhub

Copie o userparameter_rr_bind.conf no diretório (/etc/zabbix/zabbix_agentd.d) de inclusão dos agentes do Zabbix.

# cd /etc/zabbix/zabbix_agentd.d/
# wget https://raw.githubusercontent.com/remontti/Zabbix-Bind9-Statistics-Collection/master/userparameter_rr_bind.conf

Copie o script bind-stats-rr.py para dentro de /etc/zabbix/script/ e ajustaremos os poderes e permissões.

# mkdir /etc/zabbix/script
# cd /etc/zabbix/script
# wget https://raw.githubusercontent.com/remontti/Zabbix-Bind9-Statistics-Collection/master/bind-stats-rr.py
# chmod a+x /etc/zabbix/script/bind-stats-rr.py
# chown zabbix: /etc/zabbix/script/ -R
# systemctl restart zabbix-agent

Você pode receber estatísticas por zona (que serão descobertas automaticamente) adicionando a seguinte cláusula a cada definição de zona no seu named.conf.local: zone-statistics yes; Ex.:

zone "remontti.net.br" {
        type master;
        file "/var/cache/bind/master-aut/remontti.net.br/remontti.net.br.hosts";
        key-directory "/var/cache/bind/master-aut/remontti.net.br/keys/";
        dnssec-policy default;
        inline-signing yes;
        serial-update-method unixtime;
        zone-statistics yes;
};

zone "48.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.48.rev";
        zone-statistics yes;
};

zone "49.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.49.rev";
        zone-statistics yes;
};

zone "50.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.50.rev";
        zone-statistics yes;
};

zone "51.80.45.in-addr.arpa" {
        type master;
        file "/var/cache/bind/master-rev/45.80.51.rev";
        zone-statistics yes;
};

zone "3.2.1.f.4.0.8.2.ip6.arpa" {
        type master;
        file "/var/cache/bind/master-rev/2804.f123.rev";
        zone-statistics yes;
};

Não esqueça de restartar o serviço se editar o named.local.conf `systemctl restart zabbix-agent`

Baixe o arquivo RR Bind9.xml para seu computador e importe o mesmo para o seu Zabbix Server.
Vamos ter 3 novos templates:

- RR Servico Bind9 ==> Irá verificar se os serviço esta UP
- RR Servico Bind9 - Estatisticas ==> Diversas informações
- RR Servico Bind9 - Valida arquivos - Deb11 ==> Notificará sempre que um arquivo named.conf* for modificado

Coletando dados das prisões do Fail2ban

Projeto zabbix-fail2ban-discovery

Faça o download do arquivo userparameter_fail2ban.conf para o diretório /etc/zabbix/zabbix_agentd.d/

# cd /etc/zabbix/zabbix_agentd.d/
# wget https://raw.githubusercontent.com/remontti/zabbix-fail2ban-discovery/master/userparameter_fail2ban.conf

O Fail2ban funciona apenas com root por padrão. Precisaremos conceder permissão ao Zabbix para acessar o Fail2ban. Não é uma boa ideia conceder permissão de root ao Zabbix em termos de segurança. Em vez disso, permitiremos que o usuário do Zabbix use esse soquete. O agente Zabbix é executado sob o usuário zabbix. Primeiro, precisamos criar um novo grupo chamado fail2ban. Todos os usuários pertencentes a este grupo poderão acessar o Fail2ban.

Criar um grupo:

# addgroup --group fail2ban

Adicionar o usuário zabbix existente ao grupo fail2ban:

# usermod -a -G fail2ban zabbix

Em seguida, devemos alterar o proprietário do grupo do soquete de root para fail2ban:

# chown root:fail2ban /var/run/fail2ban/fail2ban.sock

Por fim, ajuste as permissões no soquete para que os membros do grupo possam acessá-lo:

# chmod g+rwx /var/run/fail2ban/fail2ban.sock

Agora podemos testar que o agente Zabbix pode chamar Fail2ban:

# su - zabbix --shell=/bin/bash -c 'fail2ban-client status sshd'

Status for the jail: sshd
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     0
|  `- File list:        /var/log/auth.log
`- Actions
   |- Currently banned: 0
   |- Total banned:     0
   `- Banned IP list:

As instruções de instalação abrangem a alteração das permissões do soquete fail2ban para acesso como um usuário não root; no entanto, essas alterações são perdidas na próxima vez que o soquete é criado.

Para tornar as alterações permanentes em um sistema em que o fail2ban é gerenciado pelo systemd, adicione o seguinte ao arquivo de substituição de serviço fail2ban

# systemctl edit fail2ban

Adicione:

[Service]
ExecStartPost=/bin/sh -c "while ! [ -S /run/fail2ban/fail2ban.sock ]; do sleep 1; done"
ExecStartPost=/bin/chgrp fail2ban /run/fail2ban/fail2ban.sock
ExecStartPost=/bin/chmod g+w /run/fail2ban/fail2ban.sock
Restart Zabbix Agent

Reinicie os serviços

# systemctl daemon-reload
# systemctl restart zabbix-agent fail2ban 

Consulte se o grupo é o fail2ban

# ls -lh /var/run/fail2ban/fail2ban.sock

srwxrwx--- 1 root fail2ban 0 jun 18 11:47 /var/run/fail2ban/fail2ban.sock

Faça download do template RR Servico Fail2ban - Monitor Filtros e importe para o Zabbix Server.

Por hoje é "só" pessoal!
Espero ter colaborado com uma pequena parcela em seu conhecimento.
Esse tutorial levei dois dias escrevendo então conto com sua ajuda para poder 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.

Recomendado:
https://www.isc.org/download/
https://downloads.isc.org/isc/bind9/9.16.15/doc/arm/Bv9ARM.pdf
Extensão para navegador:
https://chrome.google.com/webstore/detail/ipvfoo/ecanpcehffngcegjmadlcijfolapggal
https://addons.mozilla.org/en-US/firefox/addon/ipvfoo-pmarks/

Ferramentas web:
https://dnschecker.org/
https://zonemaster.net/

O post Servidor DNS Bind9 – Recursivo + Autoritativo DNSSEC + Reverso + RPZ + Fail2ban + nftables + Zabbix no Debian 11/12 apareceu primeiro em Remontti.

Distribuição utilizada: Debian 11 Bullseye / Instalação Limpa

NGINX 1.18

https://www.nginx.com

# apt install nginx

Acesse agora em seu navegador http://IP-SERVIDOR/

Se você acessar um diretório que não existe um erro dizendo que não existe, e junto informações que não é legal aparecer.

Vamos remover assinatura do nginx onde ele exibe a versão do mesmo. Ninguém precisa saber! Correto?

# sed -i 's/# server_tokens/server_tokens/' /etc/nginx/nginx.conf
# systemctl restart nginx

Pronto nosso NGINX está rodando!

PostgreSQL

# apt install postgresql postgresql-contrib

Torne-se o usuário postgres, para poder criar o banco de dados.

# su - postgres

Execute para entrar no terminal de comandos do banco.

$ psql

Para definir a senha do usuário postgres e instalar o adminpack.

postgres=# \password postgres
Digite nova senha para postgres: 
Digite-a novamente:
postgres=# CREATE EXTENSION adminpack;
CREATE EXTENSION
postgres=# \q 
$ exit

Ajustes no pg_hba.conf, assim toda alteração será necessaria validação do postgres com a senha que acabou de definir.

# vim /etc/postgresql/13/main/pg_hba.conf

Altere as seguintes linhas:

local   all             postgres                                peer
local   all             all                                     peer

Para:

local   all             postgres                                md5
local   all             all                                     md5

Reinicie o postgres

# systemctl restart postgresql

Volte para o postgres

# su - postgres

Agora para toda ação será necessário autenticar.

$ psql 
Senha para usuário postgres: !!SUA_SENHA!!
psql (13.4 (Debian 13.4-0+deb11u1))
Type "help" for help.
postgres-# \q

Para demonstração irei criar um banco/usuário teste, não esqueça de alterar a senha.

$ createuser --pwprompt teste
Digite a senha para a nova role: << NOVA SENHA PARA O USUÁRIO TESTE
Digite-a novamente: << REPITA
Senha: << SENHA DO QUE SETOU ANTES  NO COMANDO "\password postgres"

Agora crie o banco e vincule ao usuário.

$ createdb -O teste meubd
Senha: <<< SENHA DO POSTGRES 

Verifique se o mesmo foi criado.

$ psql -l 
Senha para usuário postgres: 
                               Lista dos bancos de dados
   Nome    |   Dono   | Codificação |   Collate   |    Ctype    | Privilégios de acesso 
-----------+----------+-------------+-------------+-------------+-----------------------
 meubd     | teste    | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 | 
....
....

Acessamos agora o bd teste.

$ psql -U teste -d meubd
Senha para usuário postgres: 
psql (11.11 (Debian 11.11-0+deb10u1))
Digite "help" para ajuda.

meubd=>

Vamos fazer uma "brincadeira" só para testar, criaremos uma tabela e inseriremos dados nela.

meubd=> CREATE TABLE doacao ( id int,nome text, valor text );
meubd=> INSERT INTO doacao (id,nome,valor) values (1,'Rudimar Remontti','R$ 5,00'); 
meubd=> SELECT * FROM doacao;

 id |       nome       |  valor  
----+------------------+---------
  1 | Rudimar Remontti | R$ 5,00

meubd=> \q

Se deseja remover o banco/usuário teste.

$ dropdb meubd
Senha: << SENHA DO POSTGRES
$ dropuser teste
Senha: << SENHA DO POSTGRES

Volte para root

$ exit

PHP 7.4

Incluirei algumas extensões do PHP que são normalmente utilizada também na instalação.

# apt install php php-{fpm,cli,mysql,pear,gd,gmp,bcmath,mbstring,curl,xml,zip,json,pgsql}

Agora vamos fazer a "integração" do PHP com o NGINX. Moveremos o arquivo defaul.

# mv /etc/nginx/sites-available/default /etc/nginx/sites-available/default.original

Crie um novo:

# vim /etc/nginx/sites-available/default

Ajuste:

server {
    listen 80;
    listen [::]:80;

    root /var/www/html;
    index index.php index.html index.htm;

    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
    }
}

Teste a configuração se não tem nada errado e restart os serviços:

# nginx -t
# systemctl restart nginx php7.4-fpm

Vamos criar um arquivo em PHP para testa se nosso NGINX está interpretando o PHP.

# echo '<?php phpinfo();' >> /var/www/html/teste.php

Acesse em seu navegador http://IP-SERVIDOR/teste.php

Nosso servidor WEB com PHP está funcionando!

Exemplo para multiplos domínios/subdomínios

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

Neste ex: vou representar o sub1.remontti.com.br

server {
    listen 80;
    listen [::]:80;

    root /var/www/sub1;
    index index.php index.html index.htm;

    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    server_name sub1.remontti.com.br;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
    }
}

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

Neste ex: vou representar o sub2.remontti.com.br e sub3.remontti.com.br

server {
    listen 80;
    listen [::]:80;

    root /var/www/sub2e3;
    index index.php index.html index.htm;

    server_name sub2.remontti.com.br sub3.remontti.com.br;

    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
    }
}

Link os arquivos no diretório "/etc/nginx/sites-available" que será carregado as novas configurações

# ln -s /etc/nginx/sites-available/sub1.conf /etc/nginx/sites-enabled/
# ln -s /etc/nginx/sites-available/sub2e3.conf /etc/nginx/sites-enabled/

Crie os diretórios referente a cada server_name.

# mkdir /var/www/sub1
# mkdir /var/www/sub2e3
# echo '<?php echo "Olá mundo do sub1!"; ?>' >> /var/www/sub1/index.php
# echo '<?php echo "Olá mundo do sub2e3!"; ?>' >> /var/www/sub2e3/index.php

Verifique se não tem nenhum erro e reinicie o serviço:

# nginx -t
# systemctl restart nginx

phpPgAdmin

O phppgadmin finalmente foiu atualizado para uma versão recente no repositório então iremos insta-lo via apt.

# apt install phppgadmin 

Ajustes no config.inc.php

# vim /usr/share/phppgadmin/conf/config.inc.php

Localize as linhas e ajuste:

$conf['extra_login_security'] = false;
$conf['owned_only'] = true;

Para torna-lo acessível altere o arquivo de configuração do seu NGINX, no exemplo vou colocar no arquivo default, mas você poderia estar configurando em seus domínios.

# vim /etc/nginx/sites-available/default

Adicione as linhas destacadas:

server {
    listen 80;
    listen [::]:80;

    root /var/www/html;
    index index.php index.html index.htm;

    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
    }

    location ^~ /phppgadmin {
        root /usr/share;
        try_files $uri $uri/ =404;

        #allow  192.168.87.0/24;
        #allow  2001:0db8::/32;
        #deny   all;
        #error_page  403   http://www.remontti.com.br;

        location ~ .php$ {
            include snippets/fastcgi-php.conf;
            fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
        }

    }

}

Se deseja tonar o phppgadmin acessível apenas de alguns endereços IPs (RECOMENDO) basta descomentar as linhas, e incluir seus prefixos. O error_page é para que quando a o acessante levar um proibido seja direcionado para um site.

allow  192.168.87.0/24;
allow  2001:0db8::/32;
deny   all;
error_page  403   http://www.remontti.com.br;

Verifique se não tem nenhum erro e reinicie o serviço:

# nginx -t
# systemctl restart nginx

Basta acessar http://IP-SERVIDOR/phppgadmin

:: Let's Encrypt ::

Criando certificado grátis para seus sub/domínios.

# apt install certbot python3-certbot-nginx

Para gerar o certificado use o comando:

# certbot

Não esqueça de colocar no seu cron para ele renovar o certificado, pois a cada 90 ele expira. Neste exemplo todo dia primeiro tento renovar.

# certbot -q renew

Dica, se desejar desativar o TLS1.0 e TLS1.1 após criar um certificado um arquivo é criado /etc/letsencrypt/options-ssl-apache.conf, então edite e inclua no SSLProtocol TLSv1 -TLSv1.1

# vim /etc/letsencrypt/options-ssl-nginx.conf

Ficando

#ssl_protocols            all -SSLv2 -SSLv3
ssl_protocols             all -SSLv2 -SSLv3 -TLSv1 -TLSv1.1

Reinicie o Neginx:

# systemctl restart nginx

Para testar acesse: https://www.cdn77.com/tls-test/

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.

Fontes: https://docs.nginx.com/
https://docs.nginx.com/nginx/admin-guide/web-server/web-server/

O post Servidor WEB NGINX + PHP + PostgreSQL + phpPgAdmin + Letsencrypt no Debian 11 Bullseye (LNPP) apareceu primeiro em Remontti.

Acesse seu bash e vire root com o comando su – para evitar comandos “que não existem”, e antes de mais nada tenha seu repositório atualizado.

# su -
# apt update
# apt upgrade

:: Instalação do Apache ::

# apt install apache2 apache2-utils

Após a instação, habilitamos o mod_rewrite do Apache que é muito utilizado. Este é um módulo que utiliza um mecanismo baseado em regras de reescrita. (phpipa, wordpress todos usam), e o mod_headers Este módulo fornece diretivas para controlar e modificar os cabeçalhos de solicitação e resposta HTTP. Comando para habilita-lo:

# a2enmod rewrite
# a2enmod headers

A página que vimos ao abri o ip do nosso servidor no navegador fica no diretório /var/www/html, isso está sendo informado no arquivo default do apache que fica em /etc/apache2/sites-enabled/000-default.conf, e para que nosso mod_rewrite e headers funcione corretamente será necessário adicionar alguma linhas.
O HTTP Strict Transport Security ou HSTS (RFC 6797) é um novo padrão de segurança SSL aprovado recentemente pelo IETF. Ele traz diversas melhorias para o SSL como forçar a utilização do HTTPS impedindo que sites sejam acessados usando o protocolo HTTP ou que partes do código de um site que está usando HTTPS seja executado em servidores usando o HTTP entre outras.

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

Adicione abaixo de “DocumentRoot /var/www/html” o seguinte:

	Header always set Strict-Transport-Security "max-age=63072000; includeSubDomains"

	<Directory /var/www/html/>
    		Options FollowSymLinks
    		AllowOverride All
	</Directory>

Para você aprender mais como o apache funciona recomendo: Como ter diversos sub/domínios no mesmo servidor

Por segurança remova a assinatura do apache e reinicie o apache2 para que tenha efeito as nossas alterações.

# sed -i 's/ServerTokens OS/ServerTokens Prod/' /etc/apache2/conf-available/security.conf
# sed -i 's/ServerSignature On/ServerSignature Off/' /etc/apache2/conf-available/security.conf
# systemctl restart apache2

http://[SERVER_IP]

:: Instalação do MariaDB 10.5 ::

# apt install mariadb-server mariadb-client 

Por padrão o pacote MaraiDB no Debian usa unix_socket para autenticar o login do usuário, o que basicamente significa que você pode usar o nome de usuário e a senha do sistema operacional para efetuar login no console do MariaDB.
Assim, você pode logar diretamente sem fornecer a senha root do MariaDB. Mais a frente vou ensinar como definir uma senha, não farei agora pois se você alterar nesse momento ao instalar o phpMyAdmin terá um erro.

:: Instalação do PHP 7.4 ::

Para instalação do PHP vou incluir algumas extensões que são as mais utilizada, mas seu preferir você pode optar em não instalar, as necessárias são libapache2-mod-php php php-mysql php-cli.

# apt install libapache2-mod-php php php-mysql php-cli php-pear php-gmp php-gd php-bcmath php-mbstring php-curl php-xml php-zip

É necessário reiniciar o apache para que o php tenha efeito.

# systemctl restart apache2

Consultado informações de versão:

# php --version

PHP 7.4.21 (cli) (built: Jul  2 2021 03:59:48) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies
    with Zend OPcache v7.4.21, Copyright (c), by Zend Technologies

Você pode criar um arquivo php com a função phpinfo() para mostrar todas as informações.

# echo '<?php phpinfo(); ?>' > /var/www/html/phpinfo.php

http://[SERVER_IP]/phpinfo.php

:: phpMyAdmin ::

Adivinha quem voltou para o repositório? Sim! phpmyadmin está de volta!

# apt install phpmyadmin

Selecione Apache2

Sim

Informe a senha para o banco de dados do phpmyadmin. http://senhasegura.remontti.com.br/

Aguarde finalizar… Se você é um menino que seguiu a risca não vai ter o erro seguinte, então pode pular esta parte.

POSSÍVEL ERRO!
Este erro acontece quando o usuário root do mariaDB está com senha. Caso isso acontecer, selecione IGNORAR e siga os passos a baixo.

SE OCORRER O ERRO: SIGAS ESTES PASSOS PARA RESOLUÇÃO DO PROBLEMA ACIMA.
Como o usuário root já tem senha e o script de instalção não sabe qual é a senha ele ele acaba apresentando esse erro ao criar o banco de dados bem como as tabelas do phpmyadmin, então vamos ter que criar na mão.
Se você quiser certificar qual a senha digitou na instalação do phpmyadmin basta olhar o arquivo:

# vim /etc/phpmyadmin/config-db.php

$dbuser='phpmyadmin';
$dbpass='SUPER_SENHA';
$basepath='';
$dbname='phpmyadmin';
$dbserver='localhost';
$dbport='3306';
$dbtype='mysql';

Agora entre no mariadb e vamos criar o banco bem como o usuário phpmyadmin (Use a mesma senha que está no config-db.php, ou altere também no config-db.php)

# mariadb -u root -p 

Não esqueça de alterar a SUPER_SENHA.

CREATE DATABASE phpmyadmin;
CREATE USER 'phpmyadmin'@'localhost' IDENTIFIED BY 'SUPER_SENHA';
GRANT ALL PRIVILEGES ON phpmyadmin.* TO 'phpmyadmin'@'localhost' IDENTIFIED BY 'SUPER_SENHA' WITH GRANT OPTION;
FLUSH PRIVILEGES;
EXIT;

Importe as tabelas:

# mariadb -u root -p phpmyadmin < /usr/share/phpmyadmin/sql/create_tables.sql

Pronto erro solucionado!

Para acessar o phpmyadmin:http://[SERVER_IP]/phpmyadmin/
Caso seu phpmyadmin não abrir, certifique-se que o arquivo phpmyadmin.conf está lincado em /etc/apache2/conf-enabled/

# ls -lh /etc/apache2/conf-available/ | grep phpmyadmin.conf

Caso não esteja execute o comando, e reinicie o apache:

# ln -s /etc/phpmyadmin/apache.conf /etc/apache2/conf-enabled/phpmyadmin.conf
# systemctl restart apache2

Agora tente novamente.,

Por segurança eu sempre fecho o acesso ao phpmyadmin para os IPs da administração, assim evito que uma possível vulnerabilidade venha me afetar. Para isso edite:

# vim /etc/phpmyadmin/apache.conf

Se deseja deixar o atalho para o phpmyadmin restrito apenas aos seus IP de gerencia faça da seguinte forma. Lembre-se de alterar os IPs 200.200.200.0/26 2001:db8:cafe:d0ce::/64 para os seus.

# phpMyAdmin default Apache configuration

Alias /phpmyadmin /usr/share/phpmyadmin

<Directory /usr/share/phpmyadmin>
    Options SymLinksIfOwnerMatch
    DirectoryIndex index.php

    AllowOverride All
    Require ip 127.0.0.1 ::1 200.200.200.0/26 2001:db8:cafe:d0ce::/64

    # limit libapache2-mod-php to files and directories necessary by pma
    <IfModule mod_php7.c>
        php_admin_value upload_tmp_dir /var/lib/phpmyadmin/tmp
        php_admin_value open_basedir /usr/share/phpmyadmin/:/usr/share/doc/phpmyadmin/:/etc/phpmyadmin/:/var/lib/phpmyadmin/:/usr/share/php/:/usr/share/javascript/
    </IfModule>

</Directory>

# Disallow web access to directories that don't need it
<Directory /usr/share/phpmyadmin/templates>
    Require all denied
</Directory>
<Directory /usr/share/phpmyadmin/libraries>
    Require all denied
</Directory>

Reinicie o Apache.

 systemctl restart apache2

:: Definindo senha para o root do mariaDB ::

Para aumentar a seguraçã vamos definir uma senha para o usuário root do MariDB, não esqueça de alterar ALTERE_3ST4_SENHA pela sua senha.

# mariadb -u root

USE mysql;
ALTER USER 'root'@'localhost' IDENTIFIED BY 'ALTERE_3ST4_SENHA';
FLUSH PRIVILEGES;
EXIT;

Apague seus rastros, em /root/.mysql_history temos um histórico com todos os comandos dado no terminal do MariaDB, então não é legal deixar lá em texto puro a senha que setamos!

# echo > /root/.mysql_history

:: Let's Encrypt ::

Criando certificado grátis para seus sub/domínios.

# apt install certbot python3-certbot-apache

Para gerar o certificado use o comando:

# certbot

Não esqueça de colocar no seu cron para ele renovar o certificado, pois a cada 90 ele expira. Neste exemplo todo dia primeiro tento renovar.

# certbot -q renew

Dica, se desejar desativar o TLS1.0 e TLS1.1 após criar um certificado um arquivo é criado /etc/letsencrypt/options-ssl-apache.conf, então edite e inclua no SSLProtocol TLSv1 -TLSv1.1

# vim /etc/letsencrypt/options-ssl-apache.conf

Ficando

#SSLProtocol            all -SSLv2 -SSLv3
SSLProtocol             all -SSLv2 -SSLv3 -TLSv1 -TLSv1.1

Reinicie o Apache:

# systemctl restart apache2

Para testar acesse: https://www.cdn77.com/tls-test/

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!

O post Passo-a-passo como criar um servidor WEB Apache + PHP + MariaDB + phpMyAdmin + Let’s Encrypt no Debian 11 bullseye “LAMP” apareceu primeiro em Remontti.

Primeiramente iremos precisar baixar imagem ISO do Debian, eu particularmente utilizo a ISO netinst, que durante a instalação já faz a instalação dos pacotes mais recentes usando a internet, então é lógico que vamos precisar uma conexão com a internet durante a instalação.

Outro motivo para utilizar a versão netinst é que não irei instalar nenhum pacote pois a ideia aqui é fazer uma instalação limpa! E assim instalamos os pacotes que realmente ira precisar (nada de perfumarias).

Existe duas vertentes para o download da nossa ISO. E a primeira coisa que você precisa saber que o projeto Debian é totalmente open source, logo o mesmo não ira incluir na ISO drives proprietários ou não gratuitos (non-free), então se você foi instalar em um servidor ex.: que tem uma placa intel 10gb para você não sair procurando drivers e colocando em um pendrive recomendo baixar a versão non-free (que já vem com vários drivers) um outro exemplo seria com placas de videos nvidia.

https://wiki.debian.org/SourcesList

main Consiste em pacotes compatíveis com DFSG (Debian Free Software Guidelines), que não dependem de software fora desta área para operar. Estes são os únicos pacotes considerados parte da distribuição Debian.

contrib – Contêm software compatível com DFSG, mas não possuem dependências no principal (possivelmente empacotados para o Debian em não-livre).

non-free Contém software que não está em conformidade com a DFSG, Exemplo drives proprietários, como o nome já diz não gratuitos.

– Download Debian 11 Bullseye AMD64
– Download Debian 11 Bullseye Non-Free AMD64

OBS: No exemplo minha rede pertence a classe 192.168.87.0/24 e possui DHCP ativa, porem explicarei como fazer para setar manualmente se caso desejar.

Para montar seu pendrive bootavél eu particularmente gosto do Balena etcher, mas use o da sua preferencia.

Iniciando o boot:

Selecione: Graphical Install

Portuguese (Brazil) – Portugues do Brasil

Brasil

Português Brasileiro

Neste momento ele irá identificar sua conexão de rede, e receber seus IP automaticamente via DHCP.

No entanto se sua rede não estiver configurada para entregar IP automaticamente, ira apresentar uma mensagem dizendo que a configuração falhou:

No entanto se você recebeu o IP automaticamente irá cair na tela de configuração do “Nome de Máquia:” então clique em Voltar.

Configurar a rede manualmente

Informe IP/PREFIX

Gateway

Servidores DNS

E agora voltamos a tela de Nome de Máquia

Informe seu domínio se possuir, ou deixe em branco (Se você tiver o DNS reverso configurado ele já trará seu domínio)

Defina Senha de root (administrador)

Informe seu Nome completo

Defina um nome de usuário

Defina a senha deste usuário

Selecione seu estado para a escolha do fuso horário

Chegamos ao particionamento. Aqui vamos ter várias polemicas! Para mim é interessante particionar quando você sabe realmente o que está fazendo, exemplo possuir mais de um disco, ou porejetar que uma partição não destrua o sistema.
Em VMs sempre instalo da forma automatica, não tem o porque está particionando uma máquina virtual (a não ser mais uma vez que você saiba o que quer), ou até mesmo estar fazendo algum tipo de RAID via software (Sou fã do RAID 10 espelhamento e performasse, mas quase sempre faremos isso lá na controladora, mas nada impede de fazer via software se seu servidor não possui uma controladora). Bom poderia falar um tempão aqui, mas em 90% o metodo “automático” resolve nossos problemas, então bora!

Selecione Assistido – usar o disco inteiro

Selecione o Disco

Selecione “Todos os arquivos em uma partição (para iniciantes)”, se você selecionar alguma das outras opções é muito importante que você realmente saiba oq está fazendo!

Finalizar o particionamento e escrever as mudanças no disco

Sim

Aguarde…

Não

Brasil

Eu gosto do deb.debian.org (mas pode selecionar outro se desejar)

Deixe em branco. Acredito que ninguém mais use proxy, mas se for seu caso informe seu usuário e senha da conexão HTTP.

Aguarde enquanto os espelhos (repositórios são lidos) é fundamental ter internet, caso contrário irá apresentar erro, e prosseguir a instalação vai deixar seu sistema praticamente “quebrado”.

Sim. É sempre importante ajudar a comunidade a saber quais pacotes estão sendo instalado, isso vai ajudar os desenvolvedores a serem visto pela comunidade Debian e quem sabe aquele pacote legal que você precisa compilar na próxima versão já esteja disponível via repositório.

ESSE É A PARTE MAIS IMPORTANTE PARA A INSTALAÇÃO LIMPA.
Pois não vamos instalar nenhum pacote, e sim apenas o sistema base. O único pacote que é bem provável que você irá precisar é do SSH para fazer o acesso a sua máquina.
Essa instalação é recomendada para servidores! Agora se você está fazendo essa instalação com intuito de usar alguma interface gráfica faça sua escolha e prossiga.

Sim

Seleciona o disco qual sera configurado o GRUB (Sem ele o sistema não inicia! Normalmente /dev/sda)

Aguarde a finalização

Continuar para reiniciar

Iremos ver nossa tela do GRUB (Aqui você pode selecionar um kernel anteiro instalado caso o atual apresentar algum problema…, entre recuperar até mesmo a senha de root)

E por fim chegamos a tela de login. Nesta tela você pode logar com usuário root diretamente.

Faça um SSH para o IP do seu servidor, se você não sabe qual o IP basta na tela anterior logar e digitar o comando:

ip address

Perceba que estou logando com o usuário remontti e não root, por padrão (segurança) o SSH não permite que você logue com usuário root, então use o usuário “comum” da sua instalação para logar. OBS: Não seja **** de ir trocar as configurações do SSH e permitir o root logar (Isso me deixa ***!)

Se desejar configurar o repositório non-free e contrib, para isso basta editar o arquivo /etc/apt/sources.list

# nano /etc/apt/sources.list

Agora adicione ao final de cada repositório> contrib non-free como na imagem:

Saia usando CRTL + X, em seguida atualize as informações do repositório com o comando:

# apt update

Para atualizar (se disponível) os pacotes use:

# apt upgrade

Ao usar o repositório non-free sempre recomendo a instalação dos pacotes: firmware-linux*

# apt search firmware-linux
firmware-linux/stable 20210315-3 all
  Binary firmware for various drivers in the Linux kernel (metapackage)

firmware-linux-free/stable,now 20200122-1 all [installed,automatic]
  firmware binário para vários drivers no núcleo Linux

firmware-linux-nonfree/stable 20210315-3 all
  Binary firmware for various drivers in the Linux kernel (metapackage)

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

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

# reboot

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 Instalação do Debian 11 Bullseye limpa passo-a-passo apareceu primeiro em Remontti.

Este tutorial foi escrito pelo meu amigo: Iulisloi Zacarias

Manter o relógio dos seus servidores corretamente ajustado pode evitar muita dor de cabeça. Alguns softwares simplesmente podem não funcionar com a hora incorreta, como exemplo cito aqui o DNSSEC e estrutura de chaves RPKI (nada muito grave, não é mesmo?!). Vale lembrar também que rastrear um problema ou conduzir uma auditoria fica muito mais fácil e assertivo se você manter os registros de data e hora nos logs com a informação correta.

O NTP é um protocolo que é utilizado para sincronizar a hora dos seus servidores e computador com uma fonte confiável de informação de hora, como por exemplo os servidores do projeto NTP.br. Há um tutorial muito completo sobre como manter seus servidores com a data correta aqui.

Mas você já parou para pensar sobre a segurança do NTP. As informações trafegam pela rede de forma aberta (isso não é um problema, já que saber a hora não é nenhum segredo) e sem mecanismos que permitam verificar se ela foi modificada, e isto sim pode ser um problema. Este tipo de ataque é chamado de ataque man-in-the-middle e consiste em um indivíduo mal-intencionado modificar a informação enquanto ela trafega pela rede. Além disso outro ataque bem comum é o “replay” de pacotes, ou seja, um atacante captura um pacote da comunicação original, e em seguida cria vários pacotes com as mesmas informações do pacote original, mas manipulando os campos que ele tem interesse e em seguida envia para as máquinas que ele deseja atacar. Pensando em resolver este problema de segurança, o NTS foi proposto (RFC 8915 https://datatracker.ietf.org/doc/rfc8915/).

Neste tutorial vamos utilizar o NTPsec, que é um “fork” da implementação de referência NTP e vêm ganhando popularidade no mundo Linux por ser umas das primeiras implementações NTP a ter suporte ao NTS.

É importante lembrar que o NTPsec têm a mesma função do pacote ntp no Debian e você não deve usar os dois ao mesmo tempo!

Lembrando que utilizei o Debian 10:

# cat /etc/os-release

PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"
VERSION_ID="10"
VERSION="10 (buster)"
VERSION_CODENAME=buster
ID=debian
HOME_URL="https://www.debian.org/"
SUPPORT_URL="https://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"

IMPORTANTE:
O uso do TLS 1.3 é obrigatório para o NTS e portanto este tutorial NÃO funcionará com Debian 9 ou Ubuntu 16.04.
Neste tutorial uso o repositório backports do Debian. As versões dos programas são testadas no Debian stable, no entanto não são testadas tão extensivamente como as versões dos repositórios padrão do Debian.

Se você for um usuário iniciante no Debian/Linux, não recomendo fazer esta configuração em um servidor em produção!!!!

Sem mais delongas, vamos lá…
Iniciando
Torne-se root no seu sistema utilizando o comando “su -”

$ su -

(OBS: utilize o comando “su menos”)
Vamos garantir que outros clientes NTP não estejam em execução:

# systemctl stop ntp
# systemctl stop chrony
# systemctl stop openntpd
# systemctl stop systemd-timesyncd.service
# systemctl disable ntp
# systemctl disable chrony
# systemctl disable openntpd
# systemctl disable systemd-timesyncd.service

Instalação do NTPsec e suas dependências

Como o NTS é bem recente, vamos precisar instalar o NTPsec 1.2.0. No momento em que estou escrevendo este tutorial a versão do NTPsec nos repositórios padrão do Debian 10 é a 1.1.3. Nós vamos habilitar o repositório backports (stable-bpo) para que seja possível instalar a versão 1.2.0 do NTPsec no nosso Debian 10. Será necessário instalar também o pacote “ca-certificates” para podermos validar os certificados que os servidores vão nos oferecer.

# echo "deb http://deb.debian.org/debian buster-backports main" | tee /etc/apt/sources.list.d/buster-backports.list
# apt update
# apt install -y ntpsec/buster-backports ca-certificates

Vamos ajustar as configurações do NTPsec para utilizar os servidores da Netnod (uma empresa que mantém servidores de hora para o governo da Suécia) e da Cloudflare. Por enquanto não temos servidores oficiais de hora no Brasil com suporte ao NTS (hey NTP.br, vamos?!). Você pode incluir outros servidores NTS quando eles forem disponibilizados. Seguindo a metodologia do Remontti, vamos criar um arquivo para a nossa configuração e manter cópia do arquivo de configuração original:

# mv /etc/ntpsec/ntp.conf /etc/ntpsec/ntp.conf.orig
# vim /etc/ntpsec/ntp.conf

Conteúdo do arquivo:

# /etc/ntpsec/ntp.conf, configuração para o ntpd; veja ntp.conf(5) para ajuda
# Configuraçao do drift file para o NTPsec computar os erros do relógio do seu computador
driftfile /var/lib/ntpsec/ntp.drift
leapfile /usr/share/zoneinfo/leap-seconds.list

# Configuracao do diretório de log
statsdir /var/log/ntpsec/
statistics loopstats peerstats clockstats
filegen loopstats file loopstats type day enable
filegen peerstats file peerstats type day enable
filegen clockstats file clockstats type day enable

# Lista dos servidores com suporte NTS, você pode adicionar mais servidores à lista
server nts.netnod.se:4460 nts iburst
server sth1.nts.netnod.se:4460 nts iburst
server sth2.nts.netnod.se:4460 nts iburst
server time.cloudflare.com:4460 nts

# Permite trocar informações de hora com qualquer computador mas não permite configuração
# Segundo o guia do netnod essa configuração atende 99% dos casos ;-)
restrict default kod limited nomodify nopeer noquery
restrict -6 default kod limited nomodify nopeer noquery

# Permite consultas locais
restrict 127.0.0.1
restrict -6 ::1

Crie o arquivo ntp.drift e o diretório para os logs e reinicie o serviço

# touch /var/lib/ntpsec/ntp.drift
# chown ntpsec:ntpsec /var/lib/ntpsec/ntp.drift
# mkdir /var/log/ntpsec
# chown -R ntpsec:ntpsec /var/log/ntpsec
# systemctl restart ntpsec

Vamos verificar com quais servidores estamos tentando sincronizar:

# ntpq -p -u -w

Irá listar algo como

     remote                                   refid      st t when poll reach   delay   offset   jitter
=======================================================================================================
+sth-ts.nts.netnod.se                    96.180.207.109   2 8   22   64   77 310.16ms 7.2680ms 10.631ms
*ntsts.sth1.ntp.se                       96.180.207.109   2 8   18   64   77 307.50ms 6.5467ms 13.046ms
+sth2-ts.nts.netnod.se                   156.133.237.214  2 8   22   64   77 305.86ms 4.2228ms 9.6702ms
-162.159.200.1                           10.191.8.4       3 8   23   64   77 61.953ms -31.52ms 19.442ms

Verifique a coluna “st”. Esta coluna indica o stratum (ou estrato) e o valor 16 indica que o servidor está inoperante. No meu exemplo todos os servidores estão em operação pois os valores são 2, 2, 2, e 3. Veja também que há uma linha que inicia com um asterisco (*ntsts.sth1.ntp.se), esta informação indica que o NTPsec decidiu usar este servidor como principal referência para sincronização.

A coluna “refid” indica o servidor de referência do servidor NTS que você está consultando, isto é, onde o servidor NTS busca sua informação de hora. Se você observar o valor “.NTS.” na coluna “refid” no lugar dos IPs ou nomes de servidores, significa que o NTPsec ainda está negociando a conexão segura com o servidor e ainda não foi capaz de buscar informações de hora. Outra informação importante está na coluna “t” (quarta coluna da esquerda para a direita) que indica a quantidade de “cookies” que seu computador têm para usar com o servidor. Este valor deve ser 8. Números menores na coluna “t” indica conexões interrompidas (o valor 7 pode indicar que uma requisição está em progresso).

Por fim se tudo estiver funcionando corretamente, você pode incluir o NTPsec na inicialização do Linux:

# systemctl enable ntpsec

É isso, agora a sincronização do seu relógio está protegida pela tecnologia mais avançada em termos de NTP

OBS: se a data do computador estiver muito atrasada ou muito adiantada, o NTS pode encontrar problemas em estabelecer uma conexão com o servidor de chaves do NTS e neste caso você precisa ajustar a data do servidor para um valor aproximado do atual (um dia de atraso não chega a ser um problema). Use o comando abaixo para ajustar a data, escrevendo a data no formato YYYYMMDD (Ano com quatro dígitos, Mês com dois dígitos e Dia com dois dígitos).

date +%Y%m%d -s "20210617"

Criando um servidor NTS

Como dito anteriormente, o NTS é uma forma segura de sincronizar a hora do seu computador, para tanto ele usa uma camada de segurança baseada em TLS 1.3 e assim é OBRIGATÓRIO que você use um certificado digital. O certificado não pode ser autoassinado pois não funcionará (até funciona, com algumas “gambiarras”). A maneira mais fácil é usando um certificado Let’s Encrypt, mas vai precisar que seu servidor tenham um nome FQDN (ou seja, precisará de um domínio registrado, por exemplo: nts.meuservidor.com.br).
Só para facilitar, lista dos requisitos:

• Debian 10
• Certificado Digital
• Um nome FQDN (domínio registrado)
• Cliente NTS já configurado e funcionando

Se você já tem um certificado válido no seu servidor e você vai usar o mesmo nome de máquina para o servidor NTS, você pode reusar o mesmo certificado. Caso contrário será necessário usar o certbot para solicitar um novo certificado.

Instale o certbot para obtermos o certificado digital:

# apt install certbot

Pare qualquer servidor HTTP antes de solicitar o novo certificado.

systemctl stop apache2
systemctl stop nginx

Solicite um novo certificado:

# certbot certonly --standalone

Preencha os dados do seu certificado (no meu caso eu chamei meu servidor de nts.remontti.com.br, adapte para seu servidor) e responda o resto das perguntas como o modelo abaixo

Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator standalone, Installer None
Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel): seumelhoremail@example.com

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v02.api.letsencrypt.org/directory
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(A)gree/(C)ancel: A

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about our work
encrypting the web, EFF news, campaigns, and ways to support digital freedom.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: N
Please enter in your domain name(s) (comma and/or space separated)  (Enter 'c'
to cancel): nts.remontti.com.br
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for nts.remontti.com.br
Waiting for verification...
Cleaning up challenges

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/nts.remontti.com.br/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/nts.remontti.com.br/privkey.pem
   Your cert will expire on 2021-09-21. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot
   again. To non-interactively renew *all* of your certificates, run
   "certbot renew"
 - Your account credentials have been saved in your Certbot
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Certbot so
   making regular backups of this folder is ideal.
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

Agora você á pode reiniciar o servidor HTTP, caso tenha parado o serviço antes de solicitar o certificado.

Vamos copiar o certificado para a pasta do NTPsec para garantir a segurança do mesmo, afinal não queremos dar permissões em excesso para o arquivo possibilitando que alguém roube nossa chave privada invalidando toda nossa segurança.
Não esqueça de ajustar o caminho dos arquivos do certificado digital, pois o certbot usa o nome do domínio para criar a estrutura de pastas utilizada para armazenar estes arquivos.

# cp -v /etc/letsencrypt/live/nts.remontti.com.br/privkey.pem /etc/ntpsec/key.pem
# cp -v /etc/letsencrypt/live/nts.remontti.com.br/fullchain.pem /etc/ntpsec/cert-chain.pem
# chown ntpsec:ntpsec /etc/ntpsec/key.pem
# chown ntpsec:ntpsec /etc/ntpsec/cert-chain.pem
# chmod 600 /etc/ntpsec/key.pem
# chmod 600 /etc/ntpsec/cert-chain.pem

Para ativar o servidor NTS no NTPsec, vamos editar o arquivo de configuração que criamos anteriormente

# vim /etc/ntpsec/ntp.conf

Ao final do arquivo /etc/ntpsec/ntp.conf por volta da linha 28 (ative o número de linhas no vim com o comando “:set nu”), adicione as configurações abaixo:

# Servidor NTS
nts enable
nts key /etc/ntpsec/key.pem
nts cert /etc/ntpsec/cert-chain.pem
nts cookie /var/lib/ntpsec/nts-keys

O conteúdo do arquivo ficará semelhante ao reproduzido abaixo:

# Configuraçao do drift file para o NTPsec computar os erros do relógio do seu computador
driftfile /var/lib/ntpsec/ntp.drift
leapfile /usr/share/zoneinfo/leap-seconds.list

# Configuracao do diretório de log
statsdir /var/log/ntpsec/
statistics loopstats peerstats clockstats
filegen loopstats file loopstats type day enable
filegen peerstats file peerstats type day enable
filegen clockstats file clockstats type day enable

# Lista dos servidores com suporte NTS, você pode adicionar mais servidores à lista
server nts.netnod.se:4460 nts iburst
server sth1.nts.netnod.se:4460 nts iburst
server sth2.nts.netnod.se:4460 nts iburst
server time.cloudflare.com:4460 nts

# Permite trocar informações de hora com qualquer computador mas não permite configuração
# Segundo o guia do netnod essa configuração atende 99% dos casos ;-)
restrict default kod limited nomodify nopeer noquery
restrict -6 default kod limited nomodify nopeer noquery

# Permite consultas locais
restrict 127.0.0.1
restrict -6 ::1

nts enable
nts key /etc/ntpsec/key.pem
nts cert /etc/ntpsec/cert-chain.pem
nts cookie /var/lib/ntpsec/nts-keys

Crie o arquivo utilizado pelo NTPsec para armazenar os cookies dos clientes e configure as permissões do mesmo:

# touch /var/lib/ntpsec/nts-keys
# chown ntpsec:ntpsec /var/lib/ntpsec/nts-keys
# chmod 600 /var/lib/ntpsec/nts-keys

Por fim, reinicie o NTPsec:

# systemctl restart ntpsec

Para verificar se tudo está correto, use o comando abaixo:

# systemctl status ntpsec

Verifique o campo “Active:” a informação “active (running)” indica que o NTPsec está em execução. Não se assuste com algumas linhas em vermelho, se sua saída for semelhante ao texto abaixo (principalmente a última linha “NTSs: Private Key OK”), tudo está bem:

jun 18 16:49:44 nts ntpd[54392]: NTSs: starting NTS-KE server listening on port 4460
jun 18 16:49:44 nts ntpd[54392]: NTSs: OpenSSL security level is 2
jun 18 16:49:44 nts ntpd[54392]: NTSs: starting NTS-KE server listening on port 4460
jun 18 16:49:44 nts ntpd[54392]: NTSs: listen4 worked
jun 18 16:49:44 nts ntpd[54392]: NTSs: listen6 worked
jun 18 16:49:44 nts ntpd[54392]: NTSc: Using system default root certificates.
jun 18 16:49:44 nts ntpd[54392]: NTSs: loaded certificate (chain) from /etc/ntpsec/cert-chain.pem
jun 18 16:49:44 nts ntpd[54392]: NTSs: loaded private key from /etc/ntpsec/key.pem
jun 18 16:49:44 nts ntpd[54392]: NTSs: Private Key OK

Caso não veja estas informações com o comando acima, você pode tentar usar o comando o

journalctl -u ntpsec.service

para verificar as informação de inicialização do NTPsec e rastrear possíveis erros.

Firewall com nftables

Nosso servidor está configurado e funcionando e apesar de o NTS ser muito mais seguro que o NTP, ainda assim não custa nada implementarmos um Firewall. Vamos utilizar o mesmo script do tutorial que o @Remontti preparou para o NTP.
Instale o nftables e o habilite para inciar com o sistema

# apt install -y nftables
# systemctl enable nftables

Crie o arquivo com as regras do nftables. Observe que temos duas listas chamadas acesso-ntp-local-v4 e acesso-ntp-local-v6 onde informamos todos os IPs que podem solicitar informação de hora na nossa rede (Informe os IPs de sua rede!).

# vim /etc/nftables.conf

#!/usr/sbin/nft -f

flush ruleset
 
table inet filter {
 
    # Permite os ips da sua rede
    set acesso-ntp-v4 {
        type ipv4_addr
        flags interval
        elements = { 127.0.0.1, 192.168.0.0/16, 172.16.0.0/12, 10.0.0.0/8, 100.64.0.0/10, 200.200.200.0/22 }
    }
    set acesso-ntp-v6 {
        type ipv6_addr
        flags interval
        elements = { ::1,  2804:ff4:bebe::/48 }
    }
 
    chain input {
        type filter hook input priority 0;
 
        # NTP
        ip saddr  @acesso-ntp-v4 tcp dport 4460 counter accept
        ip saddr  @acesso-ntp-v4 udp dport 123 counter accept
        ip6 saddr @acesso-ntp-v6 tcp dport 4460 counter accept
        ip6 saddr @acesso-ntp-v6 udp dport 123 counter accept
        tcp dport 4460 counter drop
        udp dport 123 counter drop
    }
    chain forward {
        type filter hook forward priority 0;
    }
    chain output {
        type filter hook output priority 0;
    }
}

Reinicie o nftables em seguida verifique se as regras foram carregadas:

# systemctl restart nftables
# nft list ruleset

Script para renovação automática do certificado

O certificado digital oferecido gratuitamente pelo Let’s Encrypt tem validade de 90 dias. Para evitar que o nosso servidor NTS fique com um certificado expirado (vencido), vamos criar um script de renovação que será executado periodicamente pelo cron.

Crie o arquivo renovassl.sh

# vim /etc/letsencrypt/renovassl.sh

com o seguinte conteúdo:

#!/bin/bash

# Variaveis
CHAINFILE=$(cat /etc/letsencrypt/renewal/* | awk -F '=' '$1~/fullchain/{print $2;exit}')
KEYFILE=$(cat /etc/letsencrypt/renewal/* | awk -F '=' '$1~/privkey/{print $2;exit}')

# Para temporariamente o servidor web
# Precisamos da porta 80 e 443 livre para o certbot conseguir renovar o certificado
# - Remova o comentário (#) da linha correspondente ao seu servidor web
# /usr/bin/systemctl stop apache2
# /usr/bin/systemctl stop nginx

# Permite o certbot se conectar a porta 80 e 443 para renovar o certificado
nft add rule inet filter input tcp dport 80 counter accept
nft add rule inet filter input tcp dport 443 counter accept


# Aguarda 10 seg (tempo do apache parar) 
sleep 10

# Renova o certificado
/usr/bin/certbot -q renew

# Aguarda o certificado renovar
sleep 30

# Aguarda 2 seg
sleep 2
 
# Restarta o servidor web
# Caso você tenha um servidor web (Apache, Nginx, Lighttpd...), reinicie o serviço
# /usr/bin/systemctl restart apache2
# /usr/bin/systemctl restart nginx

# Para o serviço ntpsec
/usr/bin/systemctl stop ntpsec

# Copia cadeia de certificado e chave privada para o diretorio do NTPsec
/usr/bin/cp $CHAINFILE /etc/ntpsec/cert-chain.pem
/usr/bin/cp $KEYFILE /etc/ntpsec/key.pem

# Altera as permissoes para o usuário speedtest conseguir ler os certificados
/usr/bin/chown ntpsec:ntpsec /etc/ntpsec/cert-chain.pem
/usr/bin/chown ntpsec:ntpsec /etc/ntpsec/key.pem
/usr/bin/chmod 600 /etc/ntpsec/cert-chain.pem
/usr/bin/chmod 600 /etc/ntpsec/key.pem

# Reinicia o serviço NTPsec
/usr/bin/systemctl start ntpsec

# Reinicia o nftables para restaurar as regras
/usr/bin/systemctl restart nftables

Lembre-se de ajustar o script conforme sua necessidade. Você pode ajustar o caminho da chave privada e da cadeia de certificados atribuindo o caminho dos arquivos correspondentes às variávies CHAINFILE e KEYFILE.

Dê permissão de execução ao arquivo renovassl.sh

# chmod +x /etc/letsencrypt/renovassl.sh

E adicione o script ao cron para que a tarefa seja executada periodicamente:

# echo '00 00   1 * *   root    /etc/letsencrypt/renovassl.sh' | tee -a /etc/crontab

Dica, se desejar desativar o TLS1.0 e TLS1.1 após criar um certificado um arquivo é criado /etc/letsencrypt/options-ssl-apache.conf, então edite e inclua no SSLProtocol TLSv1 -TLSv1.1

# vim /etc/letsencrypt/options-ssl-apache.conf

Ficando

#SSLProtocol            all -SSLv2 -SSLv3
SSLProtocol             all -SSLv2 -SSLv3 -TLSv1 -TLSv1.1

Reinicie o Apache:

# systemctl restart apache2

Para testar acesse: https://www.cdn77.com/tls-test/

Gostou? Quer ajudar 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 ficaremos felizes em saber que ajudamos. Se tiver qualquer pergunta deixe-a também. Se preferir entrar em Contato clique aqui.

O post NTS – Mantenha a hora certa em seu servidor com segurança! apareceu primeiro em Remontti.

Requisitos se Debian 10 Buster

– * Debian 10 instalação limpa
– * Servidor WEB NGINX + PHP + PostgreSQL + phpPgAdmin + Letsencrypt (Opcional phpPgAdmin + Letsencrypt)

Requisitos se Debian 11 Bullseye

– Instalação do Debian 11 Bullseye limpa passo-a-passo
– Servidor WEB NGINX + PHP + PostgreSQL + phpPgAdmin + Letsencrypt no Debian 11 Bullseye (LNPP)

Instalação do Zabbix

Para instalação do Zabbix vamos incluir o repositório do oficial do Zabbix.

# su -
# cd /tmp
# apt install wget

Repositório Debian 10

# wget https://repo.zabbix.com/zabbix/5.0/debian/pool/main/z/zabbix-release/zabbix-release_5.0-1+buster_all.deb
# dpkg -i zabbix-release_5.0-1+buster_all.deb

Repositório Debian 11

# wget https://repo.zabbix.com/zabbix/5.0/debian/pool/main/z/zabbix-release/zabbix-release_5.0-2+debian11_all.deb
# dpkg -i zabbix-release_5.0-2+debian11_all.deb

Atualize o repositório e realize a instalação

# apt update ; apt upgrade
# apt install zabbix-server-pgsql zabbix-frontend-php zabbix-nginx-conf zabbix-agent

Vamos criar uma base de dados chamada zabbix e um usuário também chamado de zabbix no PostgreSQL.
Não esqueça de alterar a senha: Use o gerador de senha: https://senhasegura.remontti.com.br/

# su - postgres
$ createuser --pwprompt zabbix
Digite a senha para a nova role:  <SENHA ZABBIX>
Digite-a novamente: <SENHA ZABBIX>
Senha: <SENHA POSTGRES CASO TENHA DEFINIDO NA INSTALAÇÃO DO MESMO>

$ createdb -O zabbix zabbix
Senha: <SENHA POSTGRES>

Importe o esquema inicial e os dados. Você será solicitado a inserir a senha que foi criada anteriormente.

$ zcat /usr/share/doc/zabbix-server-pgsql*/create.sql.gz | psql -U zabbix -d zabbix &>/dev/null
Senha para usuário zabbix: : <SENHA ZABBIX>
$ exit

Edite o arquivo zabbix_server.conf para informar os dados para conexão com do PostgreSQL.

# vim /etc/zabbix/zabbix_server.conf

Procure por # DBPassword= descomente e sete sua senha.

#...
DBPassword=<SENHA ZABBIX>
#...

Ajuste o arquivo /etc/zabbix/php-fpm.conf, descomente e defina o fuso horário correto. timezone Sua região.

# vim /etc/zabbix/php-fpm.conf

Exemplo:

; php_value[date.timezone] = Europe/Riga
php_value[date.timezone] = America/Sao_Paulo

Este é modelo padrão, altere então para sua região, também irei alterar alguns valores padrões se quiser pode remover as conf do mod_php5.c

Ajuste as configurações do nginx.

# vim /etc/nginx/conf.d/zabbix.conf 

Deixei algumas linhas comentadas como exemplo, faça de acordo com sua necessidade.

server {
        listen 80;
        listen [::]:80;
        server_name    zabbix.remontti.com.br localhost;
        #server_name   OU_SEU_IP;

        # Metodo simples para quem quer rodar em uma determinada porta
        #listen 8181;
        #listen [::]:8181;
        #server_name     _;

        root    /usr/share/zabbix;
        index   index.php;

        # Desmomente para deixar restringido apenas para determinados prefixos
        #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;
 
        location = /favicon.ico {
                log_not_found   off;
        }

        location / {
                try_files       $uri $uri/ =404;
        }

        location /assets {
                access_log      off;
                expires         10d;
        }

        location ~ /\.ht {
                deny            all;
        }

        location ~ /(api\/|conf[^\.]|include|locale) {
                deny            all;
                return          404;
        }

        location ~ [^/]\.php(/|$) {
                fastcgi_pass    unix:/var/run/php/zabbix.sock;
                fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_index   index.php;

                fastcgi_param   DOCUMENT_ROOT   /usr/share/zabbix;
                fastcgi_param   SCRIPT_FILENAME /usr/share/zabbix$fastcgi_script_name;
                fastcgi_param   PATH_TRANSLATED /usr/share/zabbix$fastcgi_script_name;

                include fastcgi_params;
                fastcgi_param   QUERY_STRING    $query_string;
                fastcgi_param   REQUEST_METHOD  $request_method;
                fastcgi_param   CONTENT_TYPE    $content_type;
                fastcgi_param   CONTENT_LENGTH  $content_length;

                fastcgi_intercept_errors        on;
                fastcgi_ignore_client_abort     off;
                fastcgi_connect_timeout         60;
                fastcgi_send_timeout            180;
                fastcgi_read_timeout            180;
                fastcgi_buffer_size             128k;
                fastcgi_buffers                 4 256k;
                fastcgi_busy_buffers_size       256k;
                fastcgi_temp_file_write_size    256k;
        }
}

Inicie o servidor Zabbix e os processos do agente e configure-os para que sejam iniciados durante o boot do sistema.

# systemctl enable zabbix-server zabbix-agent

Debian 10

# systemctl restart zabbix-server zabbix-agent nginx php7.3-fpm

Debian 11

# systemctl restart zabbix-server zabbix-agent nginx php7.4-fpm

Acesse em seu navegador http://seu_ip:porta ou http://zabbix.seudominio.com.br

Next Step

Se tudo estiver ok: Next step

Selecione PostgreSQL e informe a senha do usuário zabbix criada anteriormente, clique em Next step.

Next step

Next step

Finish

Entre com Usuário Admin e senha zabbix

Para dexa-lo em Português / Tema escuro:

Possível bug na instalação

Caso se deparar com essa tela não se assuste, faça o seguinte:

# touch /etc/zabbix/web/zabbix.conf.php
# chown www-data. /etc/zabbix/web/zabbix.conf.php

De um [Back] depois [Next] q é sucesso!

Alertas no Telegram

No Zabbix 5 temos o Telegram/Webhook, então bora aprender mexer nisso! Mas antes de mais nada será necessário criarmos um bot no Telegram.

Criando Bot no telegram

Abra o Telegram e procure por @BotFather.
Inicie a conversa com ele.

– Digite o comando /newbot para iniciar a criação de um novo bot.
– Após o comando você vai dar um nome para seu bot. Ex.: “Bot Legal RR”.
– Em seguida é necessário digitar o nome de usuário para o bot, sendo obrigatório terminar com bot. Ex.: “legallrr_bot”.
– Ao finalizar você receber informações com seu TOKEN, que vamos utilizar em seguida.

Neste exemplo nosso token para acessar a API HTTP ficou:
757396508:AAHpaoyVN-95maOCax1vDPDQBnSaZd9P5r0

Agora que o token abra o menu Administração –> Tipos de mídias

Localize o Telegram e clique nele

Edite o ParseMode para HTML e Token para o token q você acabou de criar. Marque Process tags.

Neste momento que escrevo na própria descrição da mídia telegram ele recomenda você add o bot @myidbot para descobrir o seu ID, mas parace que este bot está “dormindo”. Vamos ao metodos tradicional. Você pode receber notificações direta do seu bot ou então adiciono-lo em um grupo.

Procure pelo seu bot e comece uma conversa com ele e envie uma mensagem de teste para o mesmo, pois vamos precisar descobrir o ID do seu usuário, para que ele possa lhe enviar as mensagens.

Abra em seu seu navegador a seguinte URL https://api.telegram.org/botTOKEN/getUpdates para descobrir o ID do usuário que enviou a mensagem ou de um grupo.
Ex.: https://api.telegram.org/bot757396508:AAHpaoyVN-95maOCax1vDPDQBnSaZd9P5r0/getUpdates

:: Chat privado ::

{"ok":true,"result":[{
	"update_id":649208620,"message":{
		"message_id":2,"from":{"id":221122111,"is_bot":false,"first_name":"Rudimar","last_name":"Remontti","username":"remontti","language_code":"pt-br"},
		"chat":{"id":999999999,"first_name":"Rudimar","last_name":"Remontti","username":"remontti","type":"private"},
		"date":1541210279,"text":"Testando"
	}
}]}

ID do chat privado: 999999999

Se desejar criar um grupo também, basta adicionar seu bot a ele, após adiciona-lo envia uma mensagem como /teste para que possamos coletar o ID do grupo.

:: Chat em Grupo ::

{"ok":true,"result":[{
	"update_id":649208622,"message":{"message_id":4,"from":{
		"id":221122111,"is_bot":false,"first_name":"Rudimar","last_name":"Remontti","username":"remontti","language_code":"pt-br"},
		"chat":{"id":-88888888888,"title":"Grupo Legal","type":"group","all_members_are_administrators":true
	},"date":1541210975,"text":"/teste","entities":[{"offset":0,"length":6,"type":"bot_command"}
}]}

ID do chat grupo: -88888888888

Atenção para os grupos que sempre tem um sinal “-” na frente do ID.

Com o ID do grupo/usuário precisamos vincular ao usuário do Zabbix (Neste caso Admin)
Administração ⇒ Usuários Clique no usuário Admin

Com as opções do usuário aberto clique na aba Mídia em seguita clique no Adicionar, selecione o Tipo Telegram e insira o em Enviar para o ID.

Atualize

Agora vamos criar a ação que fará o envios dos alertas.
Configurações ⇒ Ações ⇒ Criar ação

De um nome para sua ação
Em Condição clique em adicionar: Selecione Incidente suprimido e marque Não

Na aba Operações primeiro item Operações clique em adicionar

Enviar para usuário: Selecione o Admin
Enviar apenas para: Telegram
Marque Custom message, preencha com:
Assunto:

 Problema: <b>{HOST.NAME}</b>

Mensagem

<code>{EVENT.NAME}</code>
<b>{ITEM.NAME1}</b> <i>{ITEM.VALUE1}</i>

Tempo do evento: {EVENT.AGE} 
<a href="{HOST.IP}">{HOST.IP}</a>
<i>{EVENT.SEVERITY}</i>

No item Operações de recuperação faremos praticamente o mesmo:

Assunto:

 Resolvido: <b>{HOST.NAME}</b>

Mensagem padrão

<code>{EVENT.NAME}</code>
<b>{ITEM.NAME1}</b> <i>{ITEM.VALUE1}</i>

Tempo do evento: {EVENT.AGE} 
<a href="{HOST.IP}">{HOST.IP}</a>
<i>{EVENT.SEVERITY}</i>
ID's: {ITEM.ID}/{EVENT.ID}

No item Operações de atualização
Assunto:

Problema atualizado: {EVENT.NAME}

Mensagem padrão

{USER.FULLNAME} {EVENT.UPDATE.ACTION} problema em {EVENT.UPDATE.DATE} {EVENT.UPDATE.TIME}.
{EVENT.UPDATE.MESSAGE}
O status atual do problema é {EVENT.STATUS}, reconhecido: {EVENT.ACK.STATUS}.

Operações configurada, clique em atualizar.

Pronto! Agora precisamos gerar um incidente para ver se nosso alerta será enviado para o Telegram.

O sistema de envio de mensagem está concluído!

Grafana v7/v8

Pacotes necessários:

# apt install gnupg2 apt-transport-https software-properties-common wget

Para versão 7.5.x: (Não recomendado)

# cd /tmp/
# wget https://dl.grafana.com/oss/release/grafana_7.5.11_amd64.deb
# apt install ./grafana_7.5.11_amd64.deb
# grafana-cli plugins update-all
# systemctl restart grafana-server

Para versão 8.2.x: (Não recomendado)

# cd /tmp/
# wget https://dl.grafana.com/oss/release/grafana_8.2.7_amd64.deb
# apt install ./grafana_8.2.7_amd64.deb
# grafana-cli plugins update-all
# systemctl restart grafana-server

Outras versões consulte https://grafana.com/grafana/download?edition=oss

Para Ultima versão v8.X: (Recomendado)
Vamos baixar a key do repositório e adiciona-lo

# 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

Atualize o repositório e instale o grafana

# apt update
# apt install grafana

Antes de iniciar o grafana, se deseja alterar a porta padrão 3000 (recomendo) edite:

# vim /etc/grafana/grafana.ini

Localize http_port e defina a porta de sua escolha.

# The http port  to use
;http_port = 3000

Exemplo:

http_port = 53000

Instale o Plugin Zabbix

# grafana-cli plugins install alexanderzobnin-zabbix-app

É recomendado que mensalmente você faça atualizações dos plugins instalados, com o comando:

# grafana-cli plugins update-all

Agora sim colocamos o Grafana para iniciar junto com a inicialização, ativamos e inicializamos o serviço:

# systemctl daemon-reload
# systemctl enable grafana-server
# systemctl start grafana-server

Acesse em seu navegador http://IP_URL:3000 ou pela porta que você alterou. O nome de usuário padrão é admin e a senha padrão é admin.

Ao fazer login pela primeira vez, você será solicitado a alterar sua senha.

Uhull

Integração do grafana com o Zabbix

Acesse o Configuration –> Plugins:

Localize o Zabbix e clique no mesmo

Agora ative clicando em Enable.

Volte em Configuration –> Data Sources

Clique em Add data source.

Uma nova tela com varias fontes, localize Zabbix e clique em Select

Nas opções HTTP em URL informe o endereço do seu servidor Zabbix http://IP_URL/api_jsonrpc.php. Em Access selecione Browser. Em Zabbix API details informe seu usuário e senha do Zabbix e selecione a versão correspondente.

Role até o final e e clique em Save & Test Se tudo ocorreu bem uma altera positivo com“Zabbix API version: 5.x.x” aparecerá.

Você pode também pode fazer uma conexão PostgreSQL com o banco de dados do zabbix, para tornar as coisas mais rápidas. Para isso basta “Add data source” pesquisar por PostgreSQL, então basta informa nome do banco, usuário e senha.

Vá para as configurações do data source do zabbix, localize Direct DB Connection, ative-o e selecione PostgreSQL.

Agora vem a parte mais “chata/legal” que é você montar seus gráficos, como isso é algo bem peculiar de cada um, o intuito aqui era ensinar instalar. Recomendo a leitura de Introdução ao Grafana-Zabbix do autor do plugin.

Bônus – Proxy Nginx grafana

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

Adicione:

server {
    listen 80;
    listen [::]:80;

    server_name grafana.remontti.com.br;
  
    location / {
        proxy_pass http://localhost:53000;
        proxy_set_header   Host $host;
    }
}

Cria o link para sites-enabled em seguida verifique as configurações e reinicie o serviço.

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

Simples né? Gostou e 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.

Abraço!

Fontes:
https://www.zabbix.com/download
https://www.zabbix.com/documentation/
https://grafana.com/docs/grafana/latest/installation/debian/
https://grafana.com/grafana/plugins/alexanderzobnin-zabbix-app
https://alexanderzobnin.github.io/grafana-zabbix/configuration/
https://core.telegram.org/bots

O post Instalação do Zabbix 5 LTS + Grafana 7/8 + NGINX + PostgreSQL + Notificação Telegram com Debian 10/11 apareceu primeiro em Remontti.