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.

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.

Entendendo os Ciphers e KexAlgorithms

Para abordar esses problemas, primeiro você precisa entender alguns conceitos-chave: cifras (ciphers) e algoritmos de troca de chaves (KexAlgorithms). Esses elementos são fundamentais para a segurança da sua conexão SSH e são usados para criptografar e proteger a comunicação entre seu cliente SSH e o servidor remoto.

O que são Ciphers?

Ciphers, ou cifras, são algoritmos de criptografia utilizados para proteger as informações transmitidas através de uma conexão SSH. Esses algoritmos determinam como as informações são criptografadas e descriptografadas, garantindo que a comunicação seja segura e privada.

O que são KexAlgorithms?

Por outro lado, KexAlgorithms, ou algoritmos de troca de chaves, são essenciais para estabelecer uma conexão SSH segura. Esses algoritmos são usados para negociar e concordar com a chave de criptografia que será usada durante a sessão SSH. Eles são uma parte crítica da autenticação e segurança em SSH.

A Importância das Atualizações de Firmware

Antes de entrarmos em detalhes sobre como corrigir problemas de negociação de criptografia, é importante destacar a relevância de manter o firmware do seu servidor SSH atualizado. Fabricantes e desenvolvedores de software frequentemente lançam atualizações que corrigem vulnerabilidades de segurança e melhoram a compatibilidade com os últimos padrões de segurança. Manter seu firmware atualizado é uma medida crucial para garantir a segurança do seu servidor SSH.

Protocolos Seguros e suas Diferenças

Agora que entendemos os ciphers e KexAlgorithms, é hora de falar sobre os protocolos mais seguros disponíveis para SSH. Dois dos protocolos mais usados são SSHv1 e SSHv2, e é essencial entender suas diferenças.

SSHv1

SSHv1 é uma versão mais antiga do protocolo SSH e é considerada obsoleta devido a vulnerabilidades de segurança conhecidas. Seu uso não é recomendado em ambientes modernos devido a essas fraquezas.

SSHv2

SSHv2 é a versão mais recente e segura do protocolo SSH. Oferece melhor segurança e desempenho em comparação com SSHv1. É altamente recomendado usar SSHv2 em vez de SSHv1 para garantir uma conexão SSH segura.

Corrigindo Problemas de Negociação de Criptografia

Agora que temos uma compreensão sólida dos conceitos-chave, vamos ver como corrigir problemas de negociação de criptografia em SSH.
Quando você se depara com uma mensagem de erro como “no matching cipher found” (nenhum cifrador correspondente encontrado), significa que o servidor SSH remoto e seu cliente SSH não conseguem concordar em um cifrador para a comunicação segura. Para resolver esse problema, você pode seguir estes passos:

Atualize Seu Cliente SSH: Certifique-se de que você está usando uma versão atualizada do seu cliente SSH. As versões mais recentes geralmente suportam cifradores e KexAlgorithms mais seguros.

Especifique Ciphers e KexAlgorithms: Você pode usar opções específicas na linha de comando ao se conectar, como no seguinte exemplo:

ssh -oKexAlgorithms=+diffie-hellman-group14-sha1 -oHostKeyAlgorithms=+ssh-dss -c aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc [endereço IP]

Isso indica ao seu cliente SSH quais cifradores e KexAlgorithms usar na negociação.

Contate o Administrador do Servidor: Se você é o administrador do servidor SSH, certifique-se de que ele está configurado para suportar cifradores e KexAlgorithms seguros. Considere atualizar a configuração para usar protocolos mais seguros como SSHv2.
Lembre-se de que a segurança é uma prioridade fundamental nas conexões SSH, e é crucial tomar medidas para garantir que sua comunicação seja segura e privada.

Conclusão

Neste artigo, exploramos os conceitos de cifradores e KexAlgorithms em SSH e sua importância para a segurança das conexões. Também discutimos os protocolos SSHv1 e SSHv2, destacando a preferência pelo SSHv2 devido à sua maior segurança.
Além disso, fornecemos dicas sobre como corrigir problemas de negociação de criptografia em SSH, incluindo a atualização do seu cliente SSH, especificando os cifradores e KexAlgorithms apropriados, e considerando a configuração do servidor.

Lembre-se sempre de manter seu software e firmware atualizados para garantir a segurança de suas conexões SSH e proteger seus dados de forma eficaz.

La entrada Como Corregir Problemas de Acesso Devido a Erros de Negociação de Criptografia em SSH 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.

Neste artigo, mostraremos como verificar se um site possui um certificado SSL válido usando a ferramenta de linha de comando OpenSSL no Linux.

O que é o OpenSSL?

O OpenSSL é uma biblioteca de software de código aberto usada para implementar protocolos de segurança on-line, como HTTPS, SSL e TLS. Além das bibliotecas, o OpenSSL também inclui um conjunto de ferramentas de linha de comando que podem ser usadas para executar várias tarefas de segurança.

Verificando certificados SSL com OpenSSL

Para verificar se um site possui um certificado SSL válido, você primeiro precisa abrir um terminal e inserir o seguinte comando:

openssl s_client -connect <website>:443

Neste comando, você precisa substituir <website> pelo nome de domínio do site que deseja verificar.

Assim que você inserir o comando, o OpenSSL estabelecerá uma conexão com o servidor da web e retornará informações sobre o certificado SSL. Se o site tiver um certificado SSL válido, você verá uma mensagem semelhante a esta:

Certificate chain
0 s: /C=US/ST=California/L=Los Angeles/O=Example Company/CN=www.example.com
i: /C=US/O=Let's Encrypt/CN=Let's Encrypt Authority X3

Isso significa que o site possui um certificado SSL válido emitido pela Let’s Encrypt.

No entanto, se o site não tiver um certificado SSL válido, você verá uma mensagem de erro como esta:

CONNECTED(00000003)
depth=0 CN = localhost.localdomain
verify error:num=18:self signed certificate
verify return:1
depth=0 CN = localhost.localdomain
verify error:num=10:certificate has expired
verify return:1
depth=0 CN = localhost.localdomain
verify error:num=24:invalid CA certificate
verify return:1
depth=0 CN = localhost.localdomain
verify error:num=25:hostname mismatch
verify return:1

Isso indica que o certificado SSL do site é inválido ou não confiável.

Gerando e verificando certificados SSL com OpenSSL

O OpenSSL também pode ser usado para gerar e verificar certificados SSL. Se você quiser gerar um certificado SSL para o seu próprio site, você pode usar o seguinte comando:

openssl req -x509 -newkey rsa:4096 -nodes -keyout key.pem -out cert.pem -days 365

Este comando irá gerar um certificado SSL autoassinado válido por um ano. No entanto, se você quiser um certificado SSL emitido por uma autoridade de certificação confiável, precisará adquirir um.

Se você quiser verificar se um certificado SSL é válido, pode usar o seguinte comando:

openssl x509 -in cert.pem -text -noout

Este comando mostrará informações detalhadas sobre o certificado SSL, como sua data de validade e seu emissor.

La entrada Verificação de Certificados SSL se publicó primero en Aprende IT.

O que é um editor hexadecimal?

Um editor hexadecimal, em poucas palavras, permite-lhe examinar e editar ficheiros binários. A diferença entre um editor de texto simples e um editor hexadecimal é a forma como o conteúdo é representado pelo editor.

É normalmente utilizado para aplicações de engenharia inversa. Para editar alguns bytes de um ficheiro binário, é normalmente utilizado um editor hexadecimal. Com estes editores podemos substituir texto em ficheiros binários e modificar informação sem corromper o ficheiro.

Editores hexadecimais

Hexcurse

Um dos editores de consola mais utilizados é o hexcurse. Pode facilmente abrir, editar e guardar ficheiros. Pode alternar entre hexadecimal e ASCII. O melhor deste editor é como é fácil de trabalhar a partir da consola.

Dhex

É um editor baseado em ncurses. Pode editar grandes ficheiros binários. Tem um modo “dif” para comparar ficheiros, para entrar neste modo só temos de chamar dois ficheiros em vez de apenas um.

Ghex – GNOME Hex Editor

O editor Ghex é o editor hexadecimal por excelência nos computadores de secretária do GNome. De todas as opções que temos, GHex é uma das melhores, representa o conteúdo do ficheiro em hexadecimal e ASCII, mas além disso cada fragmento do conteúdo representado em hexadecimal pode ser mostrado em decimal e octal apenas apontar com o seu cursor. O conteúdo também pode ser pesquisado.

Hexedit Hex Editor

HexEdit é um editor hexadecimal para a consola. Apresenta conteúdo em Hexadecimal e ASCII. É um dos editores de consola hexadecimal mais utilizados nos sistemas operativos modernos.

Bless Hex Editor

Bless é um dos nossos editores hexadecimal graficos favoritos. Tem uma riqueza de ferramentas e é um editor avançado que lhe permite editar grandes ficheiros. Entre as suas vantagens está o facto de suportar plugins e de poder abrir múltiplas abas em vez de abrir múltiplas janelas.

Okteta Editor

Okteta é um editor que tem características curiosas como a abertura de ficheiros remotos via HTTP, FTP, peixes e outros protocolos suportados. É um dos editores mais simples de utilizar para a visualização e edição de ficheiros binários. Okteta é o editor hexadecimal do KDE e é o sucessor do KHexEdit.

wxHexEditor

Outro dos melhores editores hexadecimal de secretária é WxHexEditor. É capaz de recuperar dados do disco rígido através da edição dos sectores a partir do próprio editor, porque permite editar grandes ficheiros e dispositivos. Consome poucos recursos e pode ser executado em plataformas Windows, Linux e Mac.

Em suma, é uma ferramenta muito boa para alguém que precisa de fazer engenharia inversa.

Hexer Binary File Editor

É um editor multibuffer (Read and Write). Não permite a edição em bloco de dispositivos. A edição da linha de comando é muito semelhante à vi/vim. Se já sabe vi será fácil de começar.

Visualizadores e outros editores

Hexyl Hex Viewer

O Hexyl não é um editor enquanto tal, é um visualizador hexadecimal. Pode destacar a cores os diferentes bytes ASCII, bytes não-ASCII, bytes NULL, ASCII em branco, etc. Ser realçado numa cor ou noutra permite-nos identificar melhor o tipo de byte. Também fornece o número de bytes e a sua representação detalhada do texto.

Xxd Hex Editor

Xdd é a melhor maneira de gerar uma descarga hexadecimal de um ficheiro binário. Pode utilizá-lo para procurar dados hexadecimais num ficheiro, pode também converter um hexdump num ficheiro binário (como urlencode e urldecode fazem).

Em suma, permite trabalhar com ficheiros binários e lixeiras hexagonais.

La entrada Os 8 melhores editores hexadecimais para linux se publicó primero en Aprende IT.

Se gostar destes artigos partilhe-o e ou deixe-nos os seus comentários nas suas redes sociais para que possamos continuar a crescer e publicar mais artigos.

Se o artigo parecer avançado e necessitar de mais informações sobre os primeiros passos no linux, pode ver os artigos da série básica:  aquí . Por outro lado, se gostar deste tipo de artigos, poderá ver todos os artigos relacionados com esta categoria.  aquí.

Vamos começar!

O que é o SNMP?

SNMP, ou Simple Network Management Protocol, é um protocolo da camada de aplicação do Modelo de rede OSI,é utilizado para trocar informações sobre o sistema (hardware e software). Isto permite-nos conhecer o estado actual do sistema, informações sobre o hardware, processos em execução, etc. Principalmente está normalmente integrado em routers, switches, servidores, firmware de alguns servidores, especialmente servidores com tecnologia da OIT (como o iLO/OA de HP, iDraq dell, etc.), impressoras em rede, etc. Por outras palavras, os dispositivos orientados para a rede já estão normalmente preparados. Mas e se eu tiver um cloud server ou um servidor recentemente instalado e quiser monitorizar o sistema via SNMP? Como o protocolo SNMP é implementado na camada de aplicação, existem múltiplas implementações para o implementar no nosso sistema linux.

Instalação do serviço

Uma das razões pelas quais escolhemos ensinar como instalar este serviço no CentOS foi também devido à sua facilidade de instalação e configuração.

Para instalar o serviço no CentOS só é necessário fazer o seguinte a partir de um terminal com o utilizador raiz:
1- Instalar o serviço SNMP:

yum -y install net-snmp net-snmp-utils

2- Fazemos o serviço começar no início

chkconfig snmpd on

3- Agora temos de configurar o serviço SNMP:

Para tal, movemos o ficheiro de configuração padrão de /etc/snmp/snmpd.conf para /etc/snmp/snmpd.conf.orig:

mv /etc/snmp/snmpd.conf /etc/snmp/snmpd.conf.orig

Editamos então o ficheiro com

vi /etc/snmp/snmpd.conf

# Mapeamos la comunidad 'ConfigUserComunity' a 'ConfigUser'
# Mapeamos la comunidad 'AllUserCommunity' a 'AllUser'
#
sec.name
source community
com2sec ConfigUser default ConfigUserComunity
com2sec AllUser default AllUserCommunity
# Map 'ConfigUser' to 'ConfigGroup' for SNMP Version 2c
# Map 'AllUser' to 'AllGroup' for SNMP Version 2c
#
sec.model sec.name
group ConfigGroup v2c ConfigUser
group AllGroup v2c AllUser
# Definimos 'SystemView' para todo lo que cuelgue de  .1.3.6.1.2.1.1 (or
.1.3.6.1.2.1.25.1)
# Definimos 'AllView' para todo lo que cuelgue de  .1
#
incl/excl subtree
view SystemView included .1.3.6.1.2.1.1
view SystemView included .1.3.6.1.2.1.25.1.1
view AllView included .1
#Definimos permisos para las comunidades
access  ConfigGroup  "" any noauth exact SystemView none   none
access  AllGroup  "" any noauth exact AllView none   none

4- Levantamos o serviço

service snmpd restart

Os dados de cada comunidade podem então ser consultados com um cliente SNMP, tal como Snmpwalk:
Sintaxe

snmpwalk -v 2c -c COMUNIDAD -O e 127.0.0.1

Para a AllUserCommunity:

snmpwalk -v 2c -c AllUserCommunity -O e 127.0.0.1

Uma vez configurado o serviço SNMP, podemos monitorizar o servidor de múltiplas formas. Uma delas é configurando um script a partir de outro ponto executando um “snmpwalk” para o servidor e se não der os valores apropriados ou não responder, desencadeará um alerta.
Outra forma é utilizar sistemas tais como librenms ou Zabbix e assim desencadear alertas mais avançados.

Lembre-se, se gostar destes artigos, partilhe-os e deixe-nos os seus comentários sobre as suas redes sociais para que possamos continuar a crescer e a publicar mais artigos.

Até breve!

La entrada Como configurar o SNMP para monitorizar o nosso servidor se publicó primero en Aprende IT.

1. wpvulnb.com

Em https://wpvulndb.com/ pode encontrar as últimas vulnerabilidades descobertas em wordpress, tanto no núcleo como em muitos plugins. Pode ver as versões afectadas, o alcance da vulnerabilidade e, em alguns casos, as ligações à exploração para verificar se é afectado pela vulnerabilidade.

2. wpscans.com

O scanner online https://wpscans.com/ realiza um scanner online completo e gera um relatório completo sobre a segurança do sítio analisado. Este relatório vai ajudar-nos muito a melhorar a segurança do wordpress analisado.

3. hackertarget

O scanner https://hackertarget.com/wordpress-security-scan/ é o scanner online mais completo que encontrámos, permitindo-lhe escolher entre vários modos. Pode executar o scanner em vários sítios, especificando-os no campo de texto fornecido. No modo de execução permite seleccionar entre 5 modos diferentes, cada um deles focado num tipo de “descoberta” sobre o alvo. O relatório por ele elaborado é bastante completo. Até indica parâmetros de servidor e também executa um scanner com nikto em alguns casos.

Embora https://hackertarget.com/extract-links/ não seja um scanner de vulnerabilidade em linha. Incluimo-lo neste artigo porque é muito útil para extrair ligações de um website.

4. wpscan

Este não é um scanner online mas pode ser descarregado a partir de https://github.com/wpscanteam/wpscan e é o scanner offline mais completo e actualizado. Graças a este scanner maravilhoso pode obter um relatório de todas as vulnerabilidades com o seu alcance, a fim de as corrigir. É perfeito se não quiser que um terceiro tenha acesso aos relatórios dos scanners feitos porque naqueles feitos a partir de webs. Não controlamos se este relatório é armazenado. Se assim for, deve ser avisado no formulário do scanner, pois os dados sobre a segurança do nosso website e das infra-estruturas seriam armazenados.

La entrada WORDPRESS: TOP 4 Melhores Scanners de Vulnerabilidade se publicó primero en Aprende IT.

A primeira coisa que temos de fazer é criar o nosso código Kernel Module C.

O caminho onde estes ficheiros são guardados é “/tmp/test-modulo”.

O ficheiro “testmodulo.c” conterá todo o código do módulo:

Em texto simples:

// Definiendo __KERNEL__ and MODULE nos permite acceder a nivel de kernel.
root@pc#undef __KERNEL__
root@pc#define __KERNEL__
root@pc#undef MODULE
root@pc#define MODULE
// Linux Kernel/LKM headers: module.h es necesario para todos los modulos y kernel.h 
//y tambien para para KERN_INFO.
root@pc#include <linux/module.h>    // Incluido para todos los modulos de kernel
root@pc#include <linux/kernel.h>    // Incluido para KERN_INFO
root@pc#include <linux/init.h>        // Incluido para __init y __exit macros

static int __init testmodulo_init(void)
{
   printk(KERN_INFO "testmodulo cargado\n"); //Se loga en el log del sistema
   //Aqui iria el codigo a ejecutar
   return 0;    // Si el retorno no es 0 
                //quiere decir que el modulo no se ha podido cargar
}

static void __exit testmodulo_cleanup(void)
{
   printk(KERN_INFO "Informacion de cleanup\n"); //se loga en el /var/log/messages
}
module_init(testmodulo_init);
module_exit(testmodulo_cleanup);

O ficheiro “Makefile”, com o qual especificamos as opções de compilação:

obj-m := testmodulo.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules
clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean

Para compilar e utilizar o módulo, é necessário fazer o seguinte a partir da consola:

Ir para o directório:

root@pc#cd /tmp/test-modulo

Compilamos com marca e gcc:

root@pc#make

Agora testmodulo.ko deve existir

root@pc#ls /tmp/test-modulo/testmodulo.ko
testmodulo.ko

Instalamos o módulo

root@pc#sudo insmod /tmp/test-modulo/testmodulo.ko
root@pc#

Verificamos se foi carregado

root@pc# cat /var/log/messages|grep testmodulo -i
Apr  9 20:52:21 sysger kernel: [15604.644410] testmodulo: module license 'unspecified' taints kernel.
Apr  9 20:52:21 sysger kernel: [15604.644859] testmodulo cargado
root@pc# lsmod|grep testmodulo
testmodulo                  192232  0

E com isto, teríamos tudo pronto para usar o nosso novo módulo.

Muito obrigado pela sua visita ao blogue! Se gostou, não se esqueça de deixar um comentário e partilhar o artigo.

La entrada LINUX : Como criar um módulo Kernel em linguagem C para executar o nosso código com os mais altos privilégios possíveis se publicó primero en Aprende IT.