Paso 1: Instalar Google Authenticator

Lo primero que necesitas es instalar Google Authenticator en tu servidor. Este programa se integra fácilmente con PAM (Pluggable Authentication Modules) para añadir 2FA a la autenticación SSH.

Abre una terminal y actualiza los paquetes con:

sudo apt update

Luego, instala el paquete necesario:

sudo apt install libpam-google-authenticator

Ahora, es momento de configurar Google Authenticator para el usuario que va a conectarse mediante SSH. Si eres tú, simplemente ejecuta:

google-authenticator

Cuando ejecutes este comando, el sistema te mostrará un código QR en la pantalla. Abre la app de Google Authenticator (o cualquier otra app compatible con TOTP, como Authy o FreeOTP) y escanea el código. Así se vincularán la app y tu servidor. La aplicación generará códigos de seis dígitos que cambiarán cada cierto tiempo y que necesitarás para iniciar sesión.

Durante el proceso de configuración, el programa te hará una serie de preguntas (como si quieres permitir tokens de emergencia o establecer límites de tiempo). Te recomiendo que leas cada opción y elijas la configuración que mejor te convenga.

Paso 2: Configurar PAM para Google Authenticator

Ahora que tienes la app configurada, hay que decirle al sistema que utilice Google Authenticator como parte del proceso de autenticación.

Para ello, edita el archivo de configuración PAM de SSH:

sudo nano /etc/pam.d/sshd

Una vez dentro del archivo, añade esta línea al inicio:

auth required pam_google_authenticator.so

Guarda los cambios (con Ctrl + O y Enter, y luego Ctrl + X para salir del editor).

Paso 3: Configurar OpenSSH para soportar 2FA
El siguiente paso es modificar la configuración del servicio SSH para que soporte el 2FA. Para ello, edita el archivo de configuración de OpenSSH:

sudo nano /etc/ssh/sshd_config

Dentro del archivo, asegúrate de que estas líneas estén configuradas correctamente:

UsePAM yes
ChallengeResponseAuthentication yes

También debes definir el método de autenticación. Vamos a exigir que se use la clave pública junto con el código TOTP, así que añade o modifica esta línea:

AuthenticationMethods publickey,keyboard-interactive

Con esta configuración, SSH pedirá primero la autenticación por clave pública y después el código de Google Authenticator.

Paso 4: Reinicia el servicio SSH

Para aplicar todos los cambios, es necesario reiniciar el servicio SSH:

sudo systemctl restart sshd

Probando la autenticación en dos pasos

Ahora que todo está configurado, es momento de probar si funciona. Cierra la sesión actual y vuelve a conectarte al servidor mediante SSH. Si todo ha ido bien, el sistema te pedirá:

• Tu clave o password para conectar por SSH.
• El código de seis dígitos generado por Google Authenticator.

Si introduces ambos correctamente, tendrás acceso al servidor. ¡Así de fácil!

Consejos adicionales

Copia de seguridad del código QR: Cuando configures Google Authenticator, guarda una copia del código QR o las claves de emergencia. Si pierdes tu teléfono, te será muy útil.
Limita los intentos fallidos: Para mayor seguridad, puedes configurar fail2ban para bloquear direcciones IP después de varios intentos fallidos.
Deshabilita la autenticación por contraseña: Si solo permites la autenticación por clave pública y 2FA, tu servidor será mucho más seguro.

La entrada Cómo proteger tu servidor SSH con Google Authenticator y 2FA se publicó primero en Aprende IT.

1. Actualización del Servidor

Primero, asegúrate de que el servidor Ubuntu esté actualizado.

Ejecutar en el servidor:

sudo apt update && sudo apt upgrade -y

2. Instalación de WireGuard

Instala WireGuard en el servidor.

Ejecutar en el servidor:

sudo apt install wireguard -y

3. Generación de Llaves del Servidor

Genera las claves privadas y públicas del servidor.

Ejecutar en el servidor:

wg genkey | tee /etc/wireguard/server_private.key | wg pubkey > /etc/wireguard/server_public.key

4. Configuración del Servidor WireGuard

Crea el archivo de configuración de WireGuard para el servidor.

Ejecutar en el servidor:

vim /etc/wireguard/wg0.conf

Agrega el siguiente contenido al archivo wg0.conf:

[Interface]
Address = 10.0.0.1/24
ListenPort = 51820
PrivateKey = 

# Habilitar NAT e IP Forwarding
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE; echo 1 > /proc/sys/net/ipv4/ip_forward
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -D FORWARD -o wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE; echo 0 > /proc/sys/net/ipv4/ip_forward

# Guardar configuración entre reinicios (opcional)
SaveConfig = true

Reemplaza con la clave privada del servidor generada previamente:

Ejecutar en el servidor:

sudo cat /etc/wireguard/server_private.key

5. Habilitación y Arranque de WireGuard

Activa y arranca el servicio WireGuard.

Ejecutar en el servidor:

sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

6. Verificación del Estado del Servidor WireGuard

Comprueba que WireGuard esté funcionando correctamente.

Ejecutar en el servidor:

sudo wg

Parte 2: Configuración de los Clientes WireGuard

1. Generación de Llaves del Cliente

Genera las claves privadas y públicas del cliente.

Ejecutar en el servidor:

wg genkey | tee /etc/wireguard/client1_private.key | wg pubkey > /etc/wireguard/client1_public.key

2. Añadir la Configuración del Cliente en el Servidor

Edita el archivo de configuración del servidor para añadir al cliente.

Ejecutar en el servidor:

sudo vim /etc/wireguard/wg0.conf

Agrega el siguiente bloque al final del archivo:

[Peer]
PublicKey = 
AllowedIPs = 10.0.0.2/32

Reemplaza con la clave pública del cliente que generaste:

Ejecutar en el servidor:

sudo cat /etc/wireguard/client1_public.key

3. Creación del Archivo de Configuración del Cliente

Crea el archivo de configuración del cliente.

Ejecutar en el servidor:

sudo nano /etc/wireguard/client1.conf

Agrega el siguiente contenido al archivo client1.conf:

[Interface]
PrivateKey = 
Address = 10.0.0.2/24
DNS = 1.1.1.1

[Peer]
PublicKey = 
Endpoint = :51820
AllowedIPs = 0.0.0.0/0

Reemplaza con la clave privada del cliente:

Ejecutar en el servidor:

sudo cat /etc/wireguard/client1_private.key

Reemplaza con la clave pública del servidor:

Ejecutar en el servidor:

sudo cat /etc/wireguard/server_public.key

Reemplaza con la dirección IP pública del servidor.

4. Generación de un Código QR para el Cliente

WireGuard permite que los clientes móviles configuren fácilmente la VPN mediante un código QR.

Instala la herramienta qrencode en el servidor:

sudo apt install qrencode -y

Genera el código QR para la configuración del cliente:

Ejecutar en el servidor:

qrencode -t ansiutf8 < /etc/wireguard/client1.conf

Este comando generará un código QR en la terminal que el cliente puede escanear con su aplicación WireGuard en Android o iOS.

5. Instalación y Configuración de WireGuard en el Cliente

Instala WireGuard en el dispositivo cliente:

Linux:

Ejecutar en el cliente:

sudo apt update && sudo apt install wireguard resolvconf iptables -y

Windows/Mac:

Descarga e instala la aplicación WireGuard desde el sitio oficial: https://www.wireguard.com/install/

Android/iOS:

Descarga la aplicación WireGuard desde Google Play Store o Apple App Store.

Configura WireGuard en el cliente:

Para Linux/Windows/Mac:

Importa el archivo de configuración client1.conf en la aplicación WireGuard.

Para dispositivos que no pueden usar un código QR, transfiere el archivo de configuración client1.conf al dispositivo cliente.

Una opción puede ser ejecutar desde el servidor el siguiente SCP si el servidor tiene acceso por SSH al cliente:

scp /etc/wireguard/client1.conf usuario@ip_cliente:/ruta/de/destino/

El fichero debe quedar en la ruta «/etc/wireguard/wg0.conf», si has podido hacer el SCP ya lo has completado, si no puedes  hacerlo, crea el fichero directamente en esa ruta y copia el contenido.

Android/iOS:

Abre la aplicación WireGuard y escanea el código QR generado anteriormente.
Conecta el Cliente a la VPN:

En la aplicación WireGuard del cliente, activa la conexión.

6. Verificación de la Conexión

Una vez conectado, prueba la conexión:

Ejecutar en el cliente:

ping 10.0.0.1

Esto debería devolver respuestas del servidor, indicando que la conexión VPN está funcionando correctamente.

Parte 3: Mantenimiento y Gestión

1. Añadir Más Clientes

Para añadir más clientes, simplemente repite los pasos de la Parte 2 para generar nuevas llaves, configurar nuevos pares en el servidor, y crear archivos de configuración para cada cliente.

2. Reiniciar el Servicio WireGuard

Si realizas cambios en la configuración del servidor, asegúrate de reiniciar el servicio:

Ejecutar en el servidor:

sudo systemctl restart wg-quick@wg0

3. Monitoreo del Estado de la VPN

Puedes verificar el estado de los pares conectados y sus estadísticas:

Ejecutar en el servidor:

sudo wg show

Vídeo

Esto te proporcionará información sobre los clientes conectados y el tráfico que están generando.

Siguiendo esta guía paso a paso, deberías poder configurar un servidor WireGuard en Ubuntu y conectar clientes de manera sencilla, incluyendo la opción de usar un código QR para la configuración en dispositivos móviles.

La entrada Cómo crear un servicio VPN con Wireguard se publicó primero en Aprende IT.

Instalación de RKHunter

Paso 1: Actualizar los Repositorios

Antes de instalar cualquier paquete nuevo, siempre es una buena práctica asegurarse de que los repositorios del sistema estén actualizados. Esto se puede hacer con el comando apt update.

apt update

Paso 2: Instalar RKHunter

Una vez que los repositorios estén actualizados, podemos proceder a instalar RKHunter junto con las herramientas básicas del sistema (coreutils).

apt install coreutils rkhunter -y

Paso 3: Descargar los Repositorios de la Base de Datos de RKHunter

Para que RKHunter funcione correctamente, necesitamos descargar los datos necesarios. Esto se puede hacer con el comando curl.

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

Configuración de RKHunter

Problema Común: No se Puede Actualizar

Si intentamos actualizar RKHunter inmediatamente después de la instalación, es probable que encontremos un error similar al siguiente:

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)

Solución: Editar el Archivo de Configuración

Para solucionar este problema, necesitamos editar el archivo de configuración de RKHunter (/etc/rkhunter.conf). Usaremos vi o cualquier otro editor de texto que prefiramos.

vi /etc/rkhunter.conf

Dentro del archivo, modificamos los siguientes parámetros:

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

Actualización de RKHunter

Después de realizar estos cambios, podemos intentar actualizar RKHunter nuevamente.

rkhunter --update

Si todo ha ido bien, deberíamos ver un mensaje indicando que los archivos se han actualizado correctamente.

Verificación de la Versión

Podemos verificar que estamos utilizando la versión más reciente de RKHunter con el siguiente comando:

rkhunter --versioncheck

Realizar un Escaneo del Sistema

Una vez que RKHunter esté configurado y actualizado, podemos proceder a realizar un escaneo completo del sistema.

rkhunter --check

Ejemplo de Salida de un Escaneo
Durante el escaneo, RKHunter verificará varios aspectos del sistema, incluyendo comandos del sistema, bibliotecas compartidas, y archivos sospechosos. Aquí hay un ejemplo de lo que podríamos 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 ]

[Press  to continue]

...

[Press  to continue]

System checks summary
=====================

File properties checks...
    Files checked: 142
    Suspect files: 0

Rootkit checks...
    Rootkits checked : 498
    Possible rootkits: 0

Applications checks...
    All checks skipped

The system checks took: 4 minutes and 25 seconds

All results have been written to the log file: /var/log/rkhunter.log

One or more warnings have been found while checking the system.
Please check the log file (/var/log/rkhunter.log)

Automatización de Escaneos con Cron

Para asegurarnos de que nuestro sistema se mantenga seguro, es una buena idea programar escaneos automáticos. Podemos hacer esto editando el archivo /etc/crontab para añadir los trabajos cron necesarios. No olvidemos modificar el correo de destino para recibir las alertas.

vi /etc/crontab

Añadimos las siguientes líneas al archivo:

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 "RKHunter Daily Scan" tu-email@example.com

Con esto, hemos configurado un trabajo cron que actualizará RKHunter diariamente a las 3 AM y realizará un escaneo diario a las 2 AM, enviando un informe por correo electrónico solo si se encuentran advertencias.

La entrada Como Proteger tu Sistema Linux: Guía Definitiva para Instalar y Usar RKHunter se publicó primero en Aprende IT.

¿Qué es Wazuh y por qué deberías usarlo?

Wazuh es una plataforma de seguridad de código abierto que proporciona detección de intrusiones, monitorización de integridad, respuesta a incidentes y auditoría de cumplimiento. Su versatilidad lo hace ideal tanto para pequeñas empresas como para grandes corporaciones. Además, al ser de código abierto, Wazuh es completamente gratuito y permite modificaciones para adaptarse a cualquier necesidad específica.

Preparativos iniciales antes de la instalación

Antes de lanzarte a la instalación de Wazuh, es crucial que prepares tu sistema. Esto implica asegurarse de que el sistema operativo esté actualizado y configurar el entorno para que soporte la instalación de Wazuh mediante Docker. Aquí te explicamos cómo:

Primero, es necesario desactivar el firewall para evitar que interfiera en el proceso de instalación. Para esto, simplemente ejecuta en la terminal:

ufw disable

Este comando desactivará el firewall, asegurando que no bloqueará ninguna de las conexiones necesarias durante la instalación.

Después, debes asegurarte de que todos los paquetes del sistema están actualizados y que git está instalado, ya que lo necesitarás para clonar el repositorio de Wazuh. Ejecuta:

apt update && apt install git

Con estos comandos, tu sistema estará actualizado y listo para la siguiente fase.

Instalación de Docker

Wazuh en Docker simplifica la gestión de dependencias y asegura que la plataforma pueda ejecutarse de manera aislada y segura. Para instalar Docker, puedes usar el script proporcionado por Docker, que configura todo automáticamente:

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

Una vez instalado Docker, es esencial que asegures su ejecución automática al iniciar el sistema:

systemctl start docker
systemctl enable docker

Estos comandos iniciarán el servicio de Docker y lo configurarán para que se inicie automáticamente en cada arranque del sistema.

Docker compose

Si instalas docker como hemos indicado anteriormente, no es necesario que instales esta herramienta, pero si ya tienes docker y no soporta «docker compose», puedes instalar docker-compose así:

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

Los siguiente comandos que tengan «docker compose» deben ejecutarse como docker-compose.

Configuración del entorno de Wazuh

Con Docker ya configurado, el siguiente paso es preparar el entorno específico para Wazuh. Dirígete al directorio óptimo para mantener organizados los archivos relacionados con la seguridad:

cd /opt

Ahora, es el momento de clonar la versión más reciente del repositorio de Wazuh para Docker:

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

Este comando descarga todos los archivos necesarios para ejecutar Wazuh en un contenedor Docker.

Generación de certificados y puesta en marcha de Wazuh

Antes de iniciar Wazuh, debes generar los certificados necesarios para el correcto funcionamiento de los componentes de Wazuh. Navega al directorio correcto y ejecuta el generador de certificados:

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

Con los certificados generados, ya estás listo para iniciar todos los servicios de Wazuh:

docker compose up -d

Este último comando levanta todos los contenedores necesarios para que Wazuh funcione adecuadamente en un modo de nodo único, ideal para entornos de prueba o pequeñas implementaciones.

Verificación de la instalación

Una vez completados todos los pasos anteriores, es importante verificar que todo esté funcionando como se espera. Puedes comprobar el estado de los contenedores de Docker para asegurarte de que todos los servicios de Wazuh están activos y ejecutándose. Además, accede a la interfaz web de Wazuh para comenzar a explorar las funcionalidades y configuraciones disponibles.

Personalización y monitorización

Con tu servidor de Wazuh ahora en funcionamiento, el siguiente paso es personalizar la configuración para adaptarla a tus necesidades específicas. Wazuh ofrece una gran variedad de opciones para configurar reglas, alertas y respuestas automáticas ante incidentes. Aprovecha la documentación disponible para explorar todas las posibilidades que te ofrece Wazuh.

Instalar y configurar tu propio servidor de Wazuh puede parecer una tarea compleja, pero siguiendo estos pasos podrás tener un sistema robusto de seguridad informática sin necesidad de grandes inversiones. No solo mejorará la seguridad de tu información, sino que también te proporcionará una herramienta poderosa para monitorizar y responder proactivamente a cualquier incidente.

Cambio de password de Wazuh

Detener el servicio usando Docker Compose:

docker compose down

Generar el hash de la nueva contraseña utilizando el contenedor de Wazuh:

Ejecuta el siguiente comando para iniciar el script de hash:

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

Ingresa la nueva contraseña cuando se te solicite y copia el hash generado.

Actualizar el archivo de usuarios internos con el hash de la nueva contraseña:

Abre el archivo con un editor de texto como vim:

vim config/wazuh_indexer/internal_users.yml

Pega el hash generado para el usuario admin.

Actualizar el archivo docker-compose.yml con la nueva contraseña:

Abre el archivo docker-compose.yml:

vim docker-compose.yml

Ingresa la nueva contraseña en las líneas 24 y 81 donde dice INDEXER_PASSWORD.

Levantar los servicios nuevamente con Docker Compose:

docker compose up -d

Esto reinicia la pila de servicios.

Acceder al contenedor y ejecutar el script de seguridad:

Accede al contenedor:

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

Define las variables y ejecuta el script de seguridad:

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

Sal del contenedor:

exit

Este proceso te permite actualizar la contraseña de administrador para Wazuh utilizando Docker, asegurándote de seguir correctamente todos los pasos para garantizar que los cambios sean efectivos.

La entrada Instala tu propio servidor de Wazuh en Ubuntu se publicó primero en Aprende IT.

En la era digital, mantener la privacidad y seguridad en línea es más crucial que nunca. Una de las maneras de proteger tu identidad y datos en la red es a través del uso de un servidor proxy SOCKS. Este tipo de proxy actúa como un intermediario entre tu dispositivo y el internet, ocultando tu dirección IP real y cifrando tu tráfico de internet. En este artículo, te guiaremos paso a paso en cómo configurar tu propio servidor proxy SOCKS en Ubuntu utilizando Dante, un servidor proxy versátil y de alto rendimiento.

Iniciando la instalación de Dante

Antes de sumergirnos en la configuración de Dante, es esencial preparar tu sistema y asegurarte de que está actualizado. Para ello, abre una terminal y ejecuta los siguientes comandos:

sudo apt update
sudo apt install dante-server

Estos comandos actualizarán la lista de paquetes de tu sistema y luego instalarán Dante, respectivamente.

Configuración del archivo danted.conf

Una vez instalado Dante, el siguiente paso es configurar el servidor proxy. Esto se hace editando el archivo de configuración danted.conf ubicado en /etc/danted/. Para ello, usa tu editor de texto preferido. Aquí, utilizaremos vim:

vim /etc/danted.conf

Dentro de este archivo, debes especificar detalles cruciales como las interfaces externa e interna, el método de autenticación y las reglas de acceso. A continuación, te mostramos una configuración ejemplo que puedes ajustar según tus necesidades:

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

# La interfaz externa (puede ser tu dirección IP pública o el nombre de la interfaz)
external: eth0

# La interfaz interna (usualmente la dirección IP de tu servidor o loopback)
internal: 0.0.0.0 port=1080

# Método de autenticación
socksmethod: username

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

# Quién puede 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 configuración define un servidor SOCKS que escucha en todas las interfaces disponibles (0.0.0.0) en el puerto 1080. Utiliza autenticación por nombre de usuario y permite conexiones desde y hacia cualquier dirección.

Creación de un usuario para el proxy

Para que el proxy sea seguro y no esté abierto al público, es necesario crear un usuario específico para la conexión. Esto se logra con los siguientes comandos:

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

Aquí, nombre_usuario es el nombre de usuario que deseas para la conexión al proxy. El comando useradd crea el usuario, y passwd te permite asignarle una contraseña.

Reiniciar y habilitar el servicio Dante

Con el usuario creado y el archivo de configuración ajustado, es momento de reiniciar el servicio Dante y asegurarse de que se ejecute al inicio del sistema:

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

Además, es importante asegurarse de que el puerto 1080, que es donde escucha el proxy, esté permitido en el firewall:

sudo ufw allow 1080/tcp

Comprobación de la conexión

Finalmente, para verificar que todo está funcionando correctamente, puedes probar la conexión a través del proxy con el siguiente comando:

curl -v -x socks5://nombre_usuario:contraseña@tu_ip_del_servidor:1080 https://cualesmiip.es/

Recuerda reemplazar nombre_usuario, contraseña y tu_ip_del_servidor con tus datos específicos. Este comando utilizará tu servidor proxy para acceder a un sitio web que muestra tu dirección IP pública, verificando así que el tráfico realmente está siendo redirigido a través del proxy SOCKS.

Configurar un servidor proxy SOCKS con Dante puede parecer complejo al principio, pero siguiendo estos pasos, podrás tener un poderoso sistema

Puedes configurar un servidor proxy SOCKS5 utilizando OpenSSH en Ubuntu 22.04, lo cual es una alternativa más sencilla y directa en ciertos casos, especialmente para uso personal o en situaciones donde ya tienes un servidor SSH configurado. A continuación, te explico cómo hacerlo:

Crear un proxy Socks 5 con OpenSSH

A diferencia de dante, con el cual podemos crear un servicio de proxy con autenticación, con OpenSSH, podemos crear un tunel en un puerto que se puede utilizar de proxy socks sin autenticación por lo que lo conveniente es que se utilice solo para localhost dentro de un solo equipo (luego explicaremos mejor esto)

Instalación de OpenSSH Server

Si aún no tienes OpenSSH Server instalado en tu servidor que va a hacer de proxy, puedes instalarlo con el siguiente comando siempre y cuando sea una distribución basada en Debian / Ubuntu:

sudo apt update
sudo apt install openssh-server

Asegúrate de que el servicio está activo y se ejecuta correctamente con:

sudo systemctl status ssh

Configuración del Servidor SSH (Opcional)

Por defecto, OpenSSH escucha en el puerto 22. Puedes ajustar configuraciones adicionales editando el archivo /etc/ssh/sshd_config, como cambiar el puerto, restringir el acceso a ciertos usuarios, etc. Si realizas cambios, recuerda reiniciar el servicio SSH:

sudo systemctl restart ssh

Uso de SSH como un Proxy SOCKS5

Para configurar un túnel SSH que funcione como un proxy SOCKS5, utiliza el siguiente comando desde tu cliente (no en el servidor). Este comando establece un túnel SSH que escucha localmente en tu máquina en el puerto especificado (por ejemplo, 1080) y redirige el tráfico a través del servidor SSH:

ssh -D 1080 -C -q -N usuario@direccion_servidor

• -D 1080 especifica que SSH debe crear un proxy SOCKS5 en el puerto local 1080.
• -C comprime los datos antes de enviarlos.
• -q habilita el modo silencioso que minimiza los mensajes de log.
• -N indica que no se ejecuten comandos remotos, útil cuando solo quieres establecer el túnel.
• usuario es tu nombre de usuario en el servidor SSH.
• direccion_servidor es la dirección IP o dominio de tu servidor SSH.

En este punto es donde comentamos que con la opción -D debemos indicar unicamente el puerto ya que si exponemos el puerto a toda la red podemos estar permitiendo que otros equipos de la red utilicen este proxy sin autenticarse:

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

Si lo comprobamos con el comando ss o con netstat podemos ver que está escuchando en todas las 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 ~]$

Sin embargo, si conectamos especificando unicamente el puerto sin 0.0.0.0 o sin ninguna IP, lo hara solo en 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 ~]$

Conexión a través del Proxy SOCKS5:

Ahora puedes configurar tu navegador o aplicación para utilizar el proxy SOCKS5 en localhost y el puerto 1080. Cada aplicación tiene una manera diferente de configurar esto, así que necesitarás revisar las preferencias o la documentación de la aplicación.

Automatización de la Conexión (Opcional):
Si necesitas que el túnel se establezca automáticamente al inicio o sin interacción manual, puedes considerar usar una herramienta como autossh para mantener la conexión del túnel abierta y reconectar en caso de que se caiga.

Esta es una forma efectiva de establecer un proxy SOCKS5 rápido para un usuario o unos pocos usuarios, especialmente útil para eludir restricciones de red o asegurar tu tráfico en redes no confiables. La principal ventaja de este método es su simplicidad y que aprovecha la infraestructura SSH existente, sin necesidad de configurar software adicional en el servidor.

La entrada Crear Proxy SOCKS con Dante y con OpenSSH se publicó primero en Aprende IT.

Comprendiendo los Ciphers y KexAlgorithms

Para abordar estos problemas, primero necesitas entender algunos conceptos clave: ciphers y KexAlgorithms. Estos elementos son fundamentales para la seguridad de tu conexión SSH y se utilizan para cifrar y proteger la comunicación entre tu cliente SSH y el servidor remoto.

¿Qué son los Ciphers?

Los ciphers, o cifrados, son algoritmos de encriptación utilizados para proteger la información transmitida a través de una conexión SSH. Estos algoritmos determinan cómo se cifra y descifra la información, garantizando que la comunicación sea segura y privada.

¿Qué son los KexAlgorithms?

Por otro lado, los KexAlgorithms, o algoritmos de intercambio de claves, son esenciales para establecer una conexión SSH segura. Estos algoritmos se utilizan para negociar y acordar la clave de cifrado que se utilizará durante la sesión SSH. Son una parte crítica de la autenticación y la seguridad en SSH.

La Importancia de las Actualizaciones de Firmware

Antes de entrar en detalles sobre cómo corregir problemas de negociación de cifrado, es importante destacar la relevancia de mantener actualizado el firmware de tu servidor SSH. Los fabricantes y desarrolladores de software suelen lanzar actualizaciones que corrigen vulnerabilidades de seguridad y mejoran la compatibilidad con los últimos estándares de seguridad. Mantener tu firmware actualizado es una medida fundamental para garantizar la seguridad de tu servidor SSH.

Protocolos Seguros y sus Diferencias

Ahora que comprendemos los ciphers y los KexAlgorithms, es hora de hablar de los protocolos más seguros disponibles para SSH. Dos de los protocolos más utilizados son SSHv1 y SSHv2, y es esencial entender sus diferencias.

SSHv1

SSHv1 es una versión más antigua del protocolo SSH y se considera obsoleta debido a las vulnerabilidades de seguridad conocidas. No se recomienda su uso en entornos modernos debido a estas debilidades.

SSHv2

SSHv2 es la versión más actual y segura del protocolo SSH. Ofrece mejor seguridad y rendimiento en comparación con SSHv1. Se recomienda encarecidamente utilizar SSHv2 en lugar de SSHv1 para garantizar una conexión SSH segura.

Corrigiendo Problemas de Negociación de Cifrado

Ahora que tenemos una comprensión sólida de los conceptos clave, veamos cómo corregir los problemas de negociación de cifrado en SSH.

Cuando te encuentres con un mensaje de error como «no matching cipher found,» significa que el servidor SSH remoto y tu cliente SSH no pueden acordar un cipher para la comunicación segura. Para resolver este problema, puedes seguir estos pasos:

Actualiza tu Cliente SSH: Asegúrate de que estás utilizando una versión actualizada de tu cliente SSH. Las versiones más recientes suelen admitir ciphers y KexAlgorithms más seguros.

Especifica Ciphers y KexAlgorithms: Puedes usar opciones específicas en la línea de comandos al conectarte, como en el siguiente ejemplo:

ssh -oKexAlgorithms=+diffie-hellman-group14-sha1 -oHostKeyAlgorithms=+ssh-dss -c aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc [dirección IP]

Esto le dice a tu cliente SSH qué ciphers y KexAlgorithms utilizar en la negociación.

Contacta al Administrador del Servidor: Si eres el administrador del servidor SSH, asegúrate de que esté configurado para admitir ciphers y KexAlgorithms seguros. Considera actualizar la configuración para utilizar protocolos más seguros como SSHv2.

Recuerda que la seguridad es una prioridad fundamental en las conexiones SSH, y es importante tomar medidas para garantizar que tu comunicación sea segura y privada.

Conclusión

En este artículo, hemos explorado los conceptos de ciphers y KexAlgorithms en SSH y su importancia para la seguridad de las conexiones. También hemos discutido los protocolos SSHv1 y SSHv2, destacando la preferencia por SSHv2 debido a su mayor seguridad.

Además, hemos proporcionado consejos sobre cómo corregir problemas de negociación de cifrado en SSH, incluyendo la actualización de tu cliente SSH, la especificación de ciphers y KexAlgorithms adecuados, y la consideración de la configuración del servidor.

Recuerda siempre mantener tu software y firmware actualizados para garantizar la seguridad de tus conexiones SSH y proteger tus datos de forma efectiva.

La entrada Cómo Corregir Problemas de Acceso por Errores de Negociación de Cifrado en SSH se publicó primero en Aprende IT.

¿Qué es Squid y por qué deberías usarlo?

Squid es un proxy de código abierto que funciona como intermediario entre tu equipo y la web, permitiéndote un control más detallado sobre el tráfico de Internet. Su popularidad radica en que es gratuito, robusto y altamente personalizable.

Preparándote para la Instalación de Squid

Antes de instalar Squid, actualiza tu sistema Ubuntu para garantizar que dispones de las últimas versiones de los paquetes con los comandos:

sudo apt-get update
sudo apt-get upgrade

Instalando Squid en Ubuntu

Para instalar Squid en Ubuntu, abre la terminal y ejecuta el siguiente comando:

sudo apt-get install squid

Configurando Squid en Ubuntu

Tras la instalación, llega la hora de la configuración. Para ello, edita el archivo de configuración squid.conf:

sudo nano /etc/squid/squid.conf

En el archivo de configuración, hay tres opciones principales a ajustar:

acl: Define a quién se le permite acceder al proxy. Puedes definir un grupo de redes para permitir el acceso con:

acl red_local src 192.168.1.0/24

En este ejemplo, permites el acceso desde la red 192.168.1.0/24.

http_access: Controla el acceso al proxy. Configúralo para permitir a los usuarios definidos en la acl:

http_access allow red_local

http_port: El puerto en el que el proxy escucha las solicitudes. Por defecto, Squid usa el puerto 3128, pero puedes cambiarlo:

http_port 8080

Recuerda guardar los cambios que hagas en el archivo squid.conf.

Verificando tu Configuración de Squid

Reinicia el servicio Squid para que los cambios tengan efecto:

sudo systemctl restart squid

Y verifica el estado del servicio:

sudo systemctl status squid

Si el estado es «active (running)», tu servidor proxy está funcionando correctamente.

Probando tu Servidor Proxy

Para probar tu servidor proxy, configura tu navegador para que utilice la IP de tu servidor y el puerto configurado en Squid. También puedes revisar los logs de Squid para ver los detalles de las solicitudes procesadas.

Optimizando tu Servidor Proxy

Squid permite optimizar la carga de las páginas mediante el caching. Para configurar este comportamiento, puedes ajustar diversas directivas en el archivo squid.conf, como el espacio en disco para el caché:

cache_dir ufs /var/spool/squid 100 16 256

En este ejemplo, /var/spool/squid es la ubicación del directorio del caché. ufs es el tipo de sistema de almacenamiento que Squid debe usar para el caché. 100 es la cantidad de espacio en disco, en megabytes, que Squid puede usar para el caché. 16 es el número de subdirectorios de primer nivel, y 256 es el número de subdirectorios de segundo nivel. Juntos, estos subdirectorios determinan el número de objetos que Squid puede almacenar en caché.

Además, Squid permite el bloqueo o acceso a ciertos sitios web utilizando listas de control de acceso, o ACLs. Podrías querer bloquear el acceso a ciertos sitios web en la red de tu oficina. Para hacerlo, puedes crear una ACL y luego usar la directiva http_access para denegar el acceso. Aquí te muestro cómo:

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

En este ejemplo, .facebook.com y .twitter.com son los sitios web a los que quieres bloquear el acceso. sitios_bloqueados es simplemente el nombre que le has dado a esta lista de control de acceso.

Si estás administrando una red con ancho de banda limitado, también puedes querer limitar la cantidad de ancho de banda que cada usuario puede usar. Squid te permite hacer esto con la directiva delay_pools. Aquí tienes un ejemplo de cómo se hace:

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

En este ejemplo, se está creando un pool de retraso (delay pool) con un límite de 10000 bytes por segundo.

Manteniendo tu Servidor Proxy

Mantener tu servidor proxy incluye monitorear su uso, revisar los logs de Squid, mantener actualizado tu sistema Ubuntu y actualizar Squid cuando sea necesario. Los logs de Squid pueden ayudarte a identificar errores y problemas de rendimiento. Para ver los logs de Squid, puedes usar el siguiente comando:

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

Este comando muestra las últimas líneas del archivo de log y actualiza la salida a medida que se añaden más líneas al log.

Finalmente, asegúrate de actualizar regularmente Squid y tu sistema Ubuntu para mantenerlo seguro y eficiente. Puedes hacer esto con los siguientes comandos:

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

Un Último Consejo

Instalar y configurar un servidor proxy puede parecer una tarea compleja, pero con algo de paciencia, te familiarizarás con el proceso. Y recuerda, siempre puedes recurrir a la comunidad de usuarios de Squid y Ubuntu si tienes alguna pregunta o te encuentras con algún problema.

¡Gracias por seguirnos en este recorrido hacia la creación de tu propio servidor proxy! Si encuentras útil este artículo, compártelo con tus colegas y amigos. Y no olvides seguirnos para más guías y consejos sobre tecnología. ¡Hasta la próxima!

La entrada Creando un Proxy para la Oficina con Squid en Ubuntu: Una Guía Detallada con Ejemplos se publicó primero en Aprende IT.

En este artículo, te mostraremos cómo comprobar si un sitio web tiene un certificado SSL válido utilizando el comando de línea de comandos OpenSSL en Linux.

¿Qué es OpenSSL?

OpenSSL es una biblioteca de software de código abierto que se utiliza para implementar protocolos de seguridad en línea, como HTTPS, SSL y TLS. Además de las bibliotecas, OpenSSL también incluye un conjunto de herramientas de línea de comandos que se pueden utilizar para realizar diversas tareas de seguridad.

Comprobando certificados SSL con OpenSSL

Para comprobar si un sitio web tiene un certificado SSL válido, primero debes abrir una terminal y escribir el siguiente comando:

openssl s_client -connect <sitio_web>:443

En este comando, debes reemplazar <sitio_web> con el nombre de dominio del sitio web que deseas comprobar.

Una vez que ingreses el comando, OpenSSL establecerá una conexión con el servidor web y devolverá información sobre el certificado SSL. Si el sitio web tiene un certificado SSL válido, verás un mensaje similar a este:

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

Esto significa que el sitio web tiene un certificado SSL válido emitido por Let’s Encrypt.

Sin embargo, si el sitio web no tiene un certificado SSL válido, verás un mensaje de error similar a este:

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

Esto indica que el certificado SSL del sitio web es inválido o no confiable.

Generando y verificando certificados SSL con OpenSSL

OpenSSL también se puede utilizar para generar y verificar certificados SSL. Si deseas generar un certificado SSL para tu propio sitio web, puedes utilizar el siguiente comando:

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

Este comando generará un certificado SSL autofirmado válido por un año. Sin embargo, si deseas un certificado SSL emitido por una autoridad de certificación confiable, deberás adquirir uno.

Si deseas verificar si un certificado SSL es válido, puedes utilizar el siguiente comando:

openssl x509 -in cert.pem -text -noout

Este comando mostrará información detallada sobre el certificado SSL, como su fecha de vencimiento y su emisor.

La entrada Comprobando certificados SSL se publicó primero en Aprende IT.

¿Qué es un editor hexadecimal?

Un editor hexadecimal, en pocas palabras, te permite examinar y editar ficheros binarios. La diferencia entre un edito texto plano y uno hexadecimal es como se representa el contenido por el editor.

Normalmente es utilizado para hacer ingeniería inversa a aplicaciones. Para editar algunos bytes de un fichero binario se suele utilizar un editor hexadecimal. Mediante estos editores podemos sustituir texto en ficheros binarios y modificar información sin corromper el fichero.

Editores hexadecimales

Hexcurse

Uno de los editores mas utilizados para consola es hexcurse. Puedes abrir, editar y guardar fácilmente ficheros. Puedes alternar entre hexadecimal y ASCII. Lo mejor de este editor es la sencillez con la que se trabaja con el desde la consola.

Dhex

Es un editor basado en ncurses. Puede editar ficheros binarios de gran tamaño. Tiene un modo «diff» para comparar ficheros, para entrar en este modo solo tenemos que que llamar a dos ficheros en lugar de solo a uno.

Ghex – GNOME Hex Editor

El editor Ghex es el editor hexadecimal por excelencia en escritorios GNome. De todas las opciones que tenemos, GHex es una de las mejores, representa el contenido del fichero en hexadecimal y ASCII pero además cada fragmento del contenido representado en hexadecimal puede ser mostrado en decimal y en octal solo tienes que señalarlo con el cursos. También se pueden realizar búsquedas en el contenido.

Hexedit Hex Editor

HexEdit es un editor hexadecimal para consola. Muestra el contenido en Hexadecimal y ASCII. Es uno de los editores hexadecimales de consola mas utilizados en sistemas operativos modernos.

Bless Hex Editor

Bless es uno de nuestros editores hexadecimales de escritorio favoritos. Tiene una gran cantidad de herramientas y es un editor avanzado que permite editar ficheros de gran tamaño. Entre sus ventajas están que soporta plugins y puedes abrir múltiples pestañas en lugar de abrir varias ventanas.

Okteta Editor

Okteta es un editor que tiene funcionalidades curiosas como por ejemplo abrir ficheros remotos mediante HTTP, FTP, fish y otros protocolos soportados. Es uno de los editores mas simples de utilizar para ver y editar ficheros binarios. Okteta es el editor hexadecimal de KDE y es el sucesor de KHexEdit.

wxHexEditor

Otro de los mejores editores hexadecimales para escritorio es WxHexEditor. Es capaz de recuperar datos del disco duro editando los sectores desde el propio editor gracias a que permite editar ficheros de gran tamaño y dispositivos. Consume pocos recursos y es posible ejecutarlo en plataformas Windows, Linux y Mac.

En definitiva, es una muy buena herramienta para alguien que necesite hacer ingeniería inversa.

Hexer Binary File Editor

Es un editor multi-buffer (Lectura y escritura). No permite la edición de dispositivos de bloque. La edición desde línea de comandos se parece mucho a vi/vim. Si ya conoces vi te será fácil empezar.

Visores y otro tipo de editores

Hexyl Hex Viewer

Hexyl no es un editor como tal, es un visor hexadecimal. Puede resaltar en colores los diferentes bytes ASCII, non-ASCII, NULL bytes, espacios en blanco ASCII, etc. Esté señalado en un color u otro nos permite identificar mejor el tipo de byte. También proporciona el número de bytes y su representación en texto con detalles.

Xxd Hex Editor

Xdd es la mejor forma de generar un volcado hexadecimal de un fichero binario. Podemos utilizarlo para buscar datos en hexadecimal en un fichero, también puede convertir un hexdump a un fichero binario (como hace urlencode y urldecode).

En definitiva, permite trabajar con ficheros binarios y volcados hexadecimales.

La entrada Los 8 mejores editores hexadecimales para linux se publicó primero en Aprende IT.

Si te gustan estos artículos compártelo y o déjanos tus comentarios en tus redes sociales para que sigamos creciendo y publicando mas artículos.

Si el articulo te parece avanzado y necesitas mas información sobre los primeros pasos en linux puedes ver los artículos de la serie básica:  aquí . Por el contrario si te gustan este tipo de artículos puedes ver todos los relacionados con esta categoría  aquí.

¡Empezamos!

¿Qué es SNMP?

SNMP o Simple Network Management Protocol es un protocolo de la capa de aplicación del modelo OSI de red, se utiliza para intercambiar información sobre el sistema (Hardware y Software). Esto nos permite conocer el estado actual del sistema, información sobre el harware, procesos corriendo, etc. Principalmente se suele integrar en routers, switches, servidores, firmware de algunos servidores  sobre todo servidores con tecnología ILO (como las iLO/OA de HP, iDraq de dell, etc), impresoras de red, etc. Es decir normalmente los dispositivos orientados a la red ya suelen venir preparados. Pero, ¿Que pasa si tengo un servidor en la nube o un servidor recien instalado y quiero monitorizar el sistema por SNMP? Como el protocolo SNMP se implementa en la capa de aplicación  hay multiples implementaciones para ponerlo en funcionamiento en nuestro sistema con linux.

Instalación del servicio

Uno de los motivos por el cual elegimos enseñar a instalar este servicio en CentOS también fue por su facilidad a la hora de instalarlo y configurarlo.

Para instalar el servicio en CentOS solo debes hacer lo siguiente desde un terminal con el usuario root:
1- Instalamos el servicio de SNMP:

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

2- Hacemos que el servicio arranque al inicio

chkconfig snmpd on

3- Ahora tenemos que configurar el servicio SNMP:

Para ello debemos movemos el fichero de configuración por defecto de /etc/snmp/snmpd.conf a /etc/snmp/snmpd.conf.orig:

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

Después editamos el fichero con

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 el servicio

service snmpd restart

Después se puede consultar los datos de cada comunidad con un cliente de SNMP como por ejemplo snmpwalk:
Sintaxis

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

Para la comunidad AllUserCommunity:

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

Una vez configurado el servicio SNMP podemos monitorizar el servidor de multiples formas. Una de ellas es configurando un script desde otro punto ejecutando un «snmpwalk» hacia el servidor y si no da los valores a propiados o no responde disparar una alerta.
Otra forma es utilizar sistemas como librenms o Zabbix y así disparar alertas mas avanzadas.

Recuerda, si te gustan estos artículos compártelo y o déjanos tus comentarios en tus redes sociales para que sigamos creciendo y publicando mas artículos.

¡Nos vemos pronto!

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