Hoy vamos a diseccionar los principales compresores, descubrir cómo sacarles el máximo partido exprimiendo nuestra CPU, y terminaremos montando un sistema de backup automatizado que nos avise por Telegram. ¡Vamos al lío!

En sistemas GNU/Linux existe una distinción fundamental que a menudo confunde a quienes empiezan: empaquetar no es comprimir.

• Empaquetar (Archivar): Consiste en juntar múltiples archivos y directorios (junto con sus permisos, propietarios y estructura de carpetas) en un único archivo continuo. El tamaño total casi no varía. El estándar indiscutible es tar (Tape Archive).
• Comprimir: Consiste en aplicar un algoritmo matemático a un único archivo para reducir el espacio que ocupa en disco. Herramientas nativas como gzip, bzip2 o xzsolo pueden comprimir un único archivo a la vez.

Por esta razón se combinan ambas tareas: primero se empaqueta una carpeta con tar y luego se pasa por el compresor (generando archivos .tar.gz, .tar.bz2 o .tar.xz).

1. El comodín del administrador: El comando tar

El comando tar permite empaquetar y comprimir en un solo paso gracias a que integra los motores de compresión directamente mediante modoles o flags.

Opciones (flags) principales de tar

• Operaciones básicas (elegir una):
  • -c (--create): Crea un nuevo archivo empaquetado.
  • -x (--extract): Extrae el contenido de un archivo empaquetado.
  • -t (--list): Lista el contenido del archivo sin extraerlo.
• Selección del algoritmo de compresión:
  • (Sin flag): Solo empaqueta (.tar).
  • -z (--gzip): Filtra a través de gzip (.tar.gz o .tgz).
  • -j (--bzip2): Filtra a través de bzip2 (.tar.bz2).
  • -J (--xz): Filtra a través de xz (.tar.xz).
• Modificadores esenciales:
  • -f (--file): Especifica el nombre del archivo de destino o lectura. Debe ser el último flag de la lista.
  • -v (--verbose): Muestra el detalle del proceso en pantalla paso a paso.
  • -C (--directory): Cambia a un directorio específico antes de realizar la extracción.
  • -p (--same-permissions): Mantiene intactos los permisos de archivos y propietarios originales.
  • --exclude=PATRÓN: Excluye archivos o carpetas que coincidan con el patrón indicado (ej. --exclude='.git').

Ejemplos prácticos con tar

# Empaquetar sin comprimir
tar -cvf backup.tar /var/www/html

# Empaquetar y comprimir con GZIP (rápido y ligero)
tar -czvf backup.tar.gz /var/www/html

# Empaquetar y comprimir con BZIP2 (ratio intermedio)
tar -cjvf backup.tar.bz2 /var/www/html

# Empaquetar y comprimir con XZ (compresión máxima)
tar -cJvf backup.tar.xz /var/www/html

# Extraer en el directorio actual (autodetecta el formato de compresión)
tar -xvf backup.tar.xz

# Extraer el contenido dentro de una carpeta concreta
tar -xvf backup.tar.gz -C /tmp/restauracion

# Listar contenido sin extraer
tar -tvf backup.tar.xz

2. Herramientas de compresión individuales: gzip, bzip2 y xz

Si trabajas con un solo archivo grande (por ejemplo, un volcado de base de datos .sql o una imagen .img), no necesitas tar. Puedes usar directamente los compresores.

¡Atención! Por defecto, estas herramientas eliminan el archivo original y dejan únicamente el comprimido, a menos que utilices el flag -k (--keep).

gzip (GNU zip)

Es el estándar por su velocidad.

• Comprimir (conservando el original):gzip -k archivo.txt
• Descomprimir:gunzip archivo.txt.gz o gzip -d archivo.txt.gz
• Niveles de compresión: Del -1 (ultra rápido, menos compresión) al -9 (máxima compresión). Por defecto aplica -6.

bzip2

Ofrece mejor ratio que gzip a costa de usar más tiempo y CPU.

• Comprimir (conservando el original):bzip2 -k archivo.txt
• Descomprimir:bunzip2 archivo.txt.bz2 o bzip2 -d archivo.txt.bz2

xz

Usa el algoritmo LZMA2. Ofrece el máximo ratio de compresión en Linux.

• Comprimir (conservando el original):xz -k archivo.txt
• Descomprimir:unxz archivo.txt.xz o xz -d archivo.txt.xz
• Uso de multinúcleo (Multithreading): Por defecto usa un solo hilo. Con -T0 utiliza todos los núcleos disponibles del procesador:
  Bashxz -k -9 -T0 imagen_sistema.img

3. Intercambio con Windows/macOS: zip y unzip

A diferencia de los comandos nativos de Linux, zip empaqueta y comprime en el mismo paso y es el estándar universal para compartir archivos con otros sistemas operativos.

Comandos y flags principales

Para crear archivos .zip:

• -r (--recurse-paths): Imprescindible para incluir subcarpetas recursivamente.
• -e (--encrypt): Solicita clave para cifrar el archivo.
• -9: Aplica compresión máxima.

# Comprimir una carpeta entera recursivamente
zip -r -9 archivo.zip /ruta/a/carpeta

# Comprimir y proteger con contraseña
zip -r -e seguro.zip /ruta/a/datos_sensibles

Para descomprimir .zip:

• -l (--list): Muestra el contenido sin extraer.
• -d (--directory): Especifica la carpeta de destino.

# Extraer en una ruta específica
unzip archivo.zip -d /home/usuario/descargas/

4. Comparativa visual de rendimiento

A la hora de elegir la herramienta adecuada, hay que sopesar tres factores: Ratio de compresión, Velocidad y Consumo de recursos (CPU).

(A continuación se muestra la tarjeta comparativa global con las métricas fijas de cada herramienta):

Comparativa de Compresores en Linux

gzip (.gz)

Ratio compresión60%

Velocidad90% (Muy Rápido)

Uso de CPU20% (Bajo)

bzip2 (.bz2)

Ratio compresión75%

Velocidad50% (Medio)

Uso de CPU50% (Medio)

xz (.xz)

Ratio compresión95% (Máximo)

Velocidad20% (Lento)

Uso de CPU90% (Alto)

zip (.zip)

Ratio compresión50%

Velocidad85% (Rápido)

Uso de CPU15% (Muy bajo)

5. Resumen rápido (Cheat Sheet)

Nivel Pro: Multihilo y Barras de Progreso

1. Exprimiendo la CPU: Compresión Multihilo

¿Por qué la compresión tradicional se siente «lenta»?

Los procesadores modernos (de un ordenador de sobremesa, un servidor o una Raspberry Pi) tienen varios núcleos o hilos (4, 8, 16 o más). Sin embargo, herramientas tradicionales como gzip, bzip2 o xz fueron creadas hace décadas, cuando los procesadores solo tenían un núcleo.

Por defecto, estos comandos solo utilizan 1 solo núcleo al 100%, dejando el resto de tu procesador totalmente ocioso. Si tienes un procesador de 8 núcleos y usas gzip, estás aprovechando apenas un 12,5% de la potencia total de tu máquina.

Las versiones multihilo al rescate

Para solucionar esto existen versiones paralelizadas (multihilo). Lo que hacen es dividir el archivo gigante en pequeños trozos, repartir cada trozo entre todos los núcleos de tu CPU para comprimirlos simultáneamente y luego juntarlos de nuevo.

Paso 1: Instalación

En la mayoría de distribuciones basadas en Debian, Ubuntu o Raspberry Pi OS, estas herramientas no vienen instaladas por defecto, pero se instalan con un solo comando:

sudo apt update
sudo apt install pigz pbzip2 pixz pv

Paso 2: Uso directo de los comandos multihilo

Funcionan con las mismas banderas básicas que ya conoces (-k para mantener el original, -d para descomprimir, -9 para máxima compresión):

# Comprimir un archivo usando TODOS los núcleos de la CPU con pigz
pigz -k -9 base_de_datos.sql
# Genera: base_de_datos.sql.gz (mucho más rápido que gzip)

# Descomprimir a máxima velocidad con pigz
pigz -d base_de_datos.sql.gz

# Comprimir con pbzip2 (repartiendo carga entre núcleos)
pbzip2 -k imagen.iso

Paso 3: Usar herramientas multihilo directamente con tar

Para que tar no use el gzip tradicional sino pigz, se utiliza el flag -I (o --use-compress-program=), indicándole a tar qué motor de compresión externo debe emplear:

# Empaquetar y comprimir una carpeta a la máxima velocidad posible usando pigz:
tar -I pigz -cvf backup_ultrarrapido.tar.gz /var/www/html

# Lo mismo para bzip2 multihilo (pbzip2):
tar -I pbzip2 -cvf backup.tar.bz2 /var/www/html

# Lo mismo para xz multihilo (pixz):
tar -I pixz -cvf backup.tar.xz /var/www/html

Nota para XZ: El comando xz moderno ya incluye soporte multihilo sin instalar nada extra. Solo debes pasarle el flag -T0 para usar todos los núcleos disponibles:

tar -I "xz -T0" -cvf backup.tar.xz /var/www/html

2. Barras de progreso en tiempo real con pv (Pipe Viewer)

Cuando comprimes un archivo o carpeta de varios Gigabytes desde la terminal, la pantalla se queda congelada sin mostrar si el proceso va por el 10% o el 90%, ni cuánto tiempo falta.

La herramienta pv (Pipe Viewer) intercepta el flujo de datos entre comandos (tuberías o pipes|) y muestra una barra de progreso en tiempo real con velocidad de transferencia, tiempo transcurrido y tiempo estimado de finalización (ETA).

[===>                                       ] 12% 14.2MB/s ETA 0:04:32

Ejemplo 1: Ver el progreso al comprimir un solo archivo grande

En lugar de lanzar gzip archivo.iso, hacemos pasar el archivo a través de pv:

pv archivo.iso | pigz > archivo.iso.gz

• Explicación: pv lee archivo.iso, muestra la barra de progreso en pantalla mientras lo pasa por la tubería | a pigz, y el resultado se guarda en archivo.iso.gz.

Ejemplo 2: Ver el progreso al empaquetar una carpeta con tar

Para ver la barra de progreso mientras empaquetas y comprimes una carpeta entera:

tar -cf - /var/www/html | pv | pigz > backup_con_progreso.tar.gz

• tar -cf - /var/www/html: Empaqueta la carpeta y, en vez de crear un archivo en disco directamente, manda el resultado a la salida estándar (-).
• | pv |: Mide los datos que van pasando y dibuja la barra de progreso.
• | pigz > backup_con_progreso.tar.gz: Recibe el flujo, lo comprime usando todos los núcleos de la CPU y lo guarda finalmente en el archivo de destino.

Ejemplo 3: Ver el progreso al descomprimir

pv backup.tar.gz | pigz -d | tar -x

• Lee el comprimido mostrando la barra de progreso (pv), lo descomprime en memoria con todos los núcleos (pigz -d) y lo extrae en el directorio actual (tar -x).

Conclusión: Pon tu disco duro a dieta

Ahora que ya conoces los entresijos del empaquetamiento y la compresión en la terminal de Linux, no hay archivo grande ni directorio pesado que se te resista. Al final, esto es como un gimnasio de alto rendimiento para tus datos: la clave no está en «sudar» CPU a lo loco, sino en elegir la rutina adecuada para cada caso:

• Si necesitas velocidad pura y cero esperas: Tira de gzip o, mejor aún, desata toda la potencia multihilo con pigz.
• Si el espacio en disco o el ancho de banda son sagrados: Dale caña con la mancuerna pesada de xz (o pixz) para arañar hasta el último megabyte.
• Y no olvides la regla de oro: Empaquetar junta los archivos ordenadamente con sus permisos; comprimir los encoge.

Dominar estas herramientas y sus alternativas modernas marca la diferencia entre un administrador que se queda mirando una pantalla congelada y uno que optimiza recursos e infraestructura como un profesional.

En la próxima entrada daremos el paso definitivo: cogeremos todo este músculo de compresión multihilo y lo integraremos en un sistema de backups automatizado con Systemd y avisos directos al móvil por Telegram.

¿Cuál es tu combinación favorita en el día a día? ¿Eres más de primar la velocidad o de buscar el máximo ahorro de espacio? ¡Nos leemos en los comentarios!

Si alguna vez has trabajado en Linux, es muy probable que te hayas topado con algo como esto: -rw-r--r--. ¿Te suena a chino? ¡No te preocupes! Hoy vamos a desentrañar el misterio de los permisos en Linux, un concepto fundamental para entender cómo funciona la seguridad y el acceso a los archivos en este sistema operativo.

Los permisos son la columna vertebral de la seguridad en Linux. Determinan quién puede leer, escribir o ejecutar un archivo o directorio. Sin un sistema de permisos robusto, cualquiera podría modificar archivos importantes del sistema o acceder a información sensible, lo que sería un caos.

¿Cómo se representan los Permisos?

Cuando ejecutas el comando ls -l en tu terminal, obtendrás una lista detallada de los archivos y directorios en el directorio actual, incluyendo la información de sus permisos. La cadena de 10 caracteres al principio de cada línea es la clave:

drwxr-xr-x 2 usuario grupo 4096 May 21 15:30 mi_directorio

-rw-r--r-- 1 usuario grupo 1024 May 21 15:30 mi_archivo.txt

Vamos a desglosar esos 10 caracteres:

• Primer carácter: Indica el tipo de archivo.
  • -: Archivo regular.
  • d: Directorio.
  • l: Enlace simbólico.
  • Y hay otros menos comunes como c para archivos de caracteres, b para archivos de bloques, etc.
• Los nueve caracteres restantes: Se dividen en tres grupos de tres, representando los permisos para:
  1. Dueño (Owner): Los primeros tres caracteres (rwx en el ejemplo anterior) definen los permisos del usuario que es el propietario del archivo o directorio.
  2. Grupo (Group): Los siguientes tres caracteres (r-x en el ejemplo) definen los permisos para los miembros del grupo al que pertenece el archivo o directorio.
  3. Otros (Others): Los últimos tres caracteres (r-x en el ejemplo) definen los permisos para todos los demás usuarios del sistema que no son el dueño ni forman parte del grupo.

Entendiendo los Permisos: rwx

Cada uno de estos tres caracteres tiene un significado específico:

• r (read – lectura):
  • Archivos: Permite ver el contenido del archivo.
  • Directorios: Permite listar el contenido del directorio (es decir, ver qué archivos y subdirectorios hay dentro).
• w (write – escritura):
  • Archivos: Permite modificar o eliminar el archivo.
  • Directorios: Permite crear, renombrar o eliminar archivos y subdirectorios dentro de ese directorio. ¡Cuidado! Para eliminar un archivo, necesitas permiso de escritura en el directorio que lo contiene, no necesariamente en el archivo en sí.
• x (execute – ejecución):
  • Archivos: Permite ejecutar el archivo si es un programa o un script.
  • Directorios: Permite «entrar» al directorio, es decir, acceder a sus contenidos y subdirectorios. Sin este permiso, no puedes usar cd para navegar a él, incluso si tienes permiso de lectura.

Cuando un permiso no está presente, se muestra un guion (-) en su lugar. Por ejemplo, -rw-r--r-- significa:

• Dueño: Puede leer y escribir (rw-).
• Grupo: Solo puede leer (r--).
• Otros: Solo puede leer (r--).

Modificando Permisos: chmod

Aquí es donde las cosas se ponen interesantes. El comando chmod (change mode) es tu mejor amigo para modificar los permisos. Hay dos formas principales de usarlo:

1. Notación Simbólica (Letras)

Esta es una forma intuitiva de agregar o quitar permisos. Usamos u (dueño), g (grupo), o (otros) y a (todos). Los operadores son + (añadir), - (quitar) y = (establecer exactamente).

• Ejemplos:
  • chmod u+x mi_script.sh: Añade permiso de ejecución al dueño del archivo mi_script.sh.
  • chmod g-w mi_archivo.txt: Quita el permiso de escritura al grupo en mi_archivo.txt.
  • chmod o=r mi_documento.pdf: Establece el permiso de lectura para «otros» en mi_documento.pdf, quitando cualquier otro permiso que tuvieran.
  • chmod a+rw archivo_compartido: Añade permisos de lectura y escritura para todos (u, g, o).

2. Notación Octal (Números)

Esta es una forma más compacta y potente de establecer permisos, especialmente útil cuando quieres configurar varios permisos a la vez. Cada permiso tiene un valor numérico:

• r (read): 4
• w (write): 2
• x (execute): 1
• – (no permiso): 0

Para cada grupo (dueño, grupo, otros), sumas los valores de los permisos deseados. Luego, concatenas estos tres números para formar un código octal de tres dígitos.

• Ejemplos:
  • rwx = 4 + 2 + 1 = 7
  • rw- = 4 + 2 + 0 = 6
  • r-x = 4 + 0 + 1 = 5
  • r-- = 4 + 0 + 0 = 4
• Aplicando chmod con notación octal:
  • chmod 755 mi_script.sh: Da permisos rwx al dueño, r-x al grupo y r-x a otros. Esto es común para scripts ejecutables.
  • chmod 644 mi_archivo.txt: Da permisos rw- al dueño, r-- al grupo y r-- a otros. Esto es común para archivos de texto.

chown y chgrp: Cambiando Dueño y Grupo

Además de los permisos, también puedes cambiar el propietario de un archivo o directorio y el grupo al que pertenece:

• chown (change owner): Cambia el dueño de un archivo o directorio.
  • chown nuevo_usuario archivo.txt
  • chown nuevo_usuario:nuevo_grupo archivo.txt (Cambia dueño y grupo a la vez)
• chgrp (change group): Cambia el grupo de un archivo o directorio.
  • chgrp nuevo_grupo archivo.txt

Permisos por Defecto: umask

Cuando creas un nuevo archivo o directorio, Linux le asigna un conjunto de permisos por defecto. Este comportamiento se controla mediante el comando umask. El umask es una máscara que resta permisos a los permisos máximos posibles (666 para archivos, 777 para directorios).

• Por ejemplo, si tu umask es 0022:
  • Para archivos (máximo 666): 666 - 022 = 644 (rw-r–r–)
  • Para directorios (máximo 777): 777 - 022 = 755 (rwxr-xr-x)

Puedes ver tu umask actual escribiendo umask en la terminal.

Los permisos en Linux son una herramienta poderosa y esencial para mantener tu sistema seguro y organizado. Dominarlos te dará un control total sobre tus archivos y directorios, y te permitirá trabajar de forma más eficiente y segura. Así que la próxima vez que veas esos misteriosos -rw-r--r--, ¡ya sabrás exactamente qué significan!

Permisos Especiales

Más Allá de rwx: Desentrañando los Permisos Especiales en Linux

Ya hemos explorado los permisos básicos de lectura (r), escritura (w) y ejecución (x) en Linux, un pilar fundamental para la seguridad del sistema. Sin embargo, el universo de los permisos en Linux esconde algunas joyas adicionales que ofrecen funcionalidades avanzadas y, a veces, cruciales para la administración del sistema. Hablamos de los permisos especiales: el setuid, setgid y el sticky bit.

Estos permisos, representados por un s o t en la cadena de permisos que obtenemos con ls -l, pueden parecer un poco intimidantes al principio. Pero una vez que entiendes su propósito, te darás cuenta de su utilidad y de por qué es tan importante manejarlos con precaución.

1. El Bit setuid (s)

El setuid (abreviatura de «set user ID») es un permiso que se aplica exclusivamente a archivos ejecutables. Su función es muy específica y potente: cuando un usuario ejecuta un archivo con el bit setuid activado, el proceso se ejecuta con los privilegios del dueño del archivo, en lugar de los privilegios del usuario que lo está ejecutando.

¿Cómo lo ves?

En la cadena de permisos, verás una s en lugar de la x para el dueño:

-rwsr-xr-x

¿Por qué es útil?

Imagina un programa como passwd, que permite a los usuarios cambiar su contraseña. Para hacer esto, passwd necesita escribir en un archivo que solo el usuario root tiene permiso para modificar (generalmente /etc/shadow). Si passwd no tuviera setuid activado, un usuario normal no podría cambiar su contraseña. Con setuid, passwd se ejecuta temporalmente con los privilegios de root (su dueño), permitiendo el cambio de contraseña.

Riesgos:

Debido a que otorga privilegios elevados, un uso indebido o una vulnerabilidad en un programa con setuid puede ser un grave riesgo de seguridad. Un atacante podría explotar un programa setuid para ejecutar código malicioso con permisos de root. Por eso, es fundamental que solo los programas de confianza y bien auditados tengan este permiso.

2. El Bit setgid (s)

Similar al setuid, el setgid (abreviatura de «set group ID») puede aplicarse tanto a archivos ejecutables como a directorios.

• En archivos ejecutables: Cuando un usuario ejecuta un archivo con el bit setgid activado, el proceso se ejecuta con los privilegios del grupo propietario del archivo, en lugar de los privilegios del grupo principal del usuario que lo ejecuta. ¿Cómo lo ves?Una s en lugar de la x para el grupo:-rwxr-sr-x Utilidad: Permite que un programa interactúe con recursos que son accesibles para un grupo específico, incluso si el usuario que lo ejecuta no pertenece a ese grupo, siempre y cuando el programa sea parte de ese grupo.
• En directorios: Este es un uso muy común y práctico. Cuando el setgid está activado en un directorio, todos los nuevos archivos y subdirectorios creados dentro de él heredarán automáticamente el grupo del directorio padre, en lugar del grupo principal del usuario que los creó. ¿Cómo lo ves?Una s en lugar de la x para el grupo:drwxr-sr-x Utilidad: Es ideal para directorios compartidos donde varios usuarios necesitan colaborar. Asegura que todos los archivos creados por diferentes usuarios en ese directorio pertenezcan al mismo grupo, simplificando la gestión de permisos para la colaboración.

3. El Sticky Bit (t)

El sticky bit es un permiso que se aplica exclusivamente a directorios. Su función principal es evitar que los usuarios eliminen o renombren archivos de otros usuarios dentro de un directorio compartido, incluso si tienen permisos de escritura sobre ese directorio.

¿Cómo lo ves?

Una t en lugar de la x para «otros»:

drwxrwxrwt

Utilidad: El ejemplo más claro y común es el directorio /tmp. En este directorio, cualquier usuario puede crear archivos y directorios. Sin el sticky bit, un usuario malicioso podría eliminar los archivos temporales de otro usuario. Con el sticky bit activado, un usuario solo puede eliminar o renombrar los archivos y directorios que él mismo posee dentro de /tmp.

Cómo Establecer los Permisos Especiales con chmod

Al igual que los permisos básicos, los permisos especiales se pueden establecer utilizando el comando chmod, tanto con la notación simbólica como con la octal.

Notación Simbólica:

• setuid:u+s
  • chmod u+s mi_programa
• setgid:g+s
  • chmod g+s mi_directorio_compartido
• sticky bit:o+t
  • chmod o+t /var/tmp

Notación Octal:

Los permisos especiales tienen un dígito octal adicional que se coloca al principio de los tres dígitos de permisos básicos (dueño, grupo, otros).

• setuid: 4
• setgid: 2
• sticky bit: 1

Para aplicar, sumas el valor del permiso especial que quieres establecer y lo antepones al número octal de los permisos básicos.

• Ejemplos:
  • setuid en un ejecutable (755): chmod 4755 mi_programa (El 4 activa setuid, luego 755 para rwxr-xr-x)
  • setgid en un directorio (770): chmod 2770 mi_directorio_compartido (El 2 activa setgid, luego 770 para rwxrwx---)
  • sticky bit en un directorio (777): chmod 1777 /tmp (El 1 activa sticky bit, luego 777 para rwxrwxrwx)
  Si un permiso especial se activa pero el permiso de ejecución (x) no está presente para el grupo o «otros», la s o t se mostrará en mayúscula (S o T), indicando que el permiso especial está presente, pero el bit de ejecución está ausente.

Conclusión

Los permisos especiales en Linux son herramientas poderosas que, cuando se usan correctamente, mejoran la funcionalidad y la seguridad del sistema. Sin embargo, su poder conlleva una gran responsabilidad. El uso descuidado de setuid y setgid en programas no confiables puede abrir brechas de seguridad significativas.

Entender cuándo y cómo aplicar estos permisos, junto con los permisos básicos, es un paso crucial para cualquier administrador de sistemas o usuario avanzado de Linux. Así que, la próxima vez que veas una s o una t en un listado de permisos, ya sabrás que estás frente a algo más que simple lectura, escritura o ejecución. ¡Estás ante una capa adicional de control y seguridad en tu sistema Linux!

SSH, (Secure Shell), es un protocolo de administración remota por el cual los usuarios pueden controlar sus equipos a través de Internet.

Se creó para sustituir a Telnet, un protocolo no cifrado que no ofrecía ningún tipo de seguridad a los usuarios. En cambio, SSH hace uso de las técnicas de criptografía más innovadoras con el claro objetivo de que todas las comunicaciones realizadas entre los usuarios y los servidores remotos sean seguras. Dispone de una herramienta que permite autenticar al usuario remoto para posteriormente transferir las entradas desde el cliente al host y, finalmente, realizar la salida de vuelta a los usuarios.

Instalación del servidor y del cliente

Generalmente SSH suele venir preinstalado en tu distribución Linux, pero si no es así, procede a la instalación de los paquetes correspondientes, que son el servidor (openssh-server) y el cliente (openssh-client).

sudo apt-get install openssh-server openssh-client -y

El paquete openssh-server proporciona el demonio sshd y sftp-server que permite a los clientes ssh y scp establecer conexiones seguras, y a los clientes sftp transferir archivos, también de forma segura.

El paquete openssh-client proporciona los clientes de ssh, scp y sftp, los programas ssh-agent y ssh-add para hacer más cómoda la identificación de clave pública, y las utilidades ssh-keygen, ssh-keyscan, ssh-copy-id y ssh-argv0.

Test SSH

Comprueba que el servidor SSH está habilitado y activo con la siguiente orden:

sudo systemctl status sshd

En la siguiente imagen, resaltado en color verde vemos que es así.

Hay otros comandos como son:

sudo systemctl enable sshd = Habilita el servicio

sudo systemctl disable sshd = Deshabilita el servicio

sudo systemctl start sshd = Inicia el servicio

sudo systemctl stop sshd = Para el servicio

sudo systemctl restart sshd = reinicia el servicio

sudo systemctl reload sshd = recarga el servicio

Nota: La diferencia entre restart y reload es que, en el primer caso, el servicio se detiene y se vuelve a iniciar y en el segundo caso, sigue ejecutándose y vuelve a leer los archivos de configuración.

Archivos de configuración:

SSH dispone de varios archivos de configuración, que son los siguientes:

/etc/ssh/sshd_config: Archivo principal de configuración del servidor SSH.

/etc/ssh/ssh_config: Archivo principal de configuración de los clientes SSH.

~/.ssh/config: Archivo personal de cada usuario. Contiene la configuración utilizada por los clientes SSH. Permite al usuario local utilizar una configuración distinta a la definida en el archivo /etc/ssh/ssh_config.

~/.ssh/known_hosts: Archivo personal de cada usuario. Contiene las firmas digitales de los servidores SSH a los que se conectan los clientes. Cuando éstas firmas cambian, se pueden actualizar ejecutando el comando ssh-keygen -R, pasando el nombre del anfitrión o la IP del anfitrión como argumento. Este comando elimina la entrada correspondiente en el archivo ~/.ssh/known_hosts y, permite añadir de nuevo al anfitrión con una nueva firma digital. La sintaxis genérica sería:

ssh-keygen -R nombre_o_ip_del_servidor_SSH

~/.ssh/authorized_keys: Archivo personal para cada usuario. Contiene los certificados de los clientes SSH, para permitir autenticación hacia servidores SSH sin requerir contraseña.

Configurar SSH

Tras la instalación procederemos a la configuración del servidor, para ello, editaremos el fichero de configuración /etc/ssh/sshd_config.

NOTA: es importante hacer copia de seguridad del archivo /etc/ssh/sshd_config antes de realizar cualquier cambio.

sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

Abrimos el archivo de confirmación con nano

sudo nano /etc/ssh/sshd_config

Una forma de elevar la seguridad del servidor SSH, consiste en cambiar el número de puerto predeterminado por otro que sólo el administrador del sistema conozca. Aunque cambiar de puerto disminuye considerablemente la posibilidad de una intrusión, en internet hay cientos de robots escaneando IPs y sus respectivos puertos abiertos, con lo que al final acabas siendo encontrado.

Port – De forma predeterminada, el servicio SSH escucha por el puerto 22. Los atacantes buscarán servidores que estén escuchando dicho puerto.Sustituye el 22 a otro puerto, preferiblemente entre el 1024 y 65535.

Veamos algunas otras opciones interesantes a tener en cuenta a la hora de configurar el servidor:

AddressFamily -Especifica qué familia de direcciones debe utilizar sshd. Los argumentos válidos son any (por defecto), inet (sólo IPv4), o inet6 (sólo IPv6).

ListenAddress – De forma predeterminada, el servicio SSH escuchará peticiones a través de todas las direcciones IP correspondientes a todas las interfaces de red del sistema. La directriz por defecto sería: ListenAddress 0.0.0.0. Si queremos que el servidor solo escuche por la interfaz de red con IP 192.168.1.30, a la cual sólo se puede acceder desde la red local:

ListenAddress 192.168.1.30

LoginGraceTime – Establece el tiempo, en segundos, durante el cual la pantalla de login estará disponible para que el usuario introduzca su nombre de usuario y contraseña, si no lo hace durante ese período de tiempo el login se cerrará, evitando así dejar por tiempo indeterminado pantallas de login sin que nadie las use, o que alguien este intentando mediante un script adivinar un usuario y su contraseña. Si el valor es 0, no hay límite de tiempo para que un usuario se autentique, lo cual no es recomendable ya que de esta forma un atacante podría utilizar ataques de fuerza bruta o usando métodos de diccionario para adivinar la contraseña, por lo tanto no es recomendable dejar esta directriz a 0. Lo podemos dejar en 10 segundos.

LoginGraceTime 10

PermitRootLogin – Probablemente sea la directriz de seguridad más importante que podemos establecer para asegurar nuestro servidor SSH. En los sistemas Unix y Linux se crea por defecto al usuario root, lo que implica que ya conocemos la existencia de al menos un usuario, ¡y que usuario!, con privilegios de adnimistrador. Muchos ataques de fuerza bruta se concentran en atacar al usuario root con la esperanza de que tenga una contraseña débil.
Sabiendo una parte de la ecuación (root) solo será cuestión de tiempo para que alguien con paciencia y suerte vulnere el sistema. En esta directriz denegamos el acceso al usuario root y por lo tanto, cualquier intento de ataque directo al usuario root será inútil.
Al denegar el acceso al usuario root, cada vez que necesitemos realizar tareas administrativas, accederemos como un usuario normal y una vez dentro, utilizando alguno de los comandos su o sudo podremos realizar dichas tareas administrativas. Por lo tanto, denegando el acceso al usuario root, el atacante tendrá que acertar tanto el nombre de un usuario del sistema como su contraseña, algo que disminuye notablemente la probabilidad de una intrusión.

StrictModes – En esta directriz se establece que sshd revisara los modos y permisos de los archivos de los usuarios y el directorio $HOME de el usuario antes de aceptar la sesión. Esto es normalmente deseable porque a veces algunos usuarios dejan sus directorios, accidentalmente, con permiso de escritura para cualquiera. El valor predeterminado es yes, por lo tanto, lo dejaremos con su valor predeterminado.

StrictModes yes

MaxAuthTries – El valor de esta directriz establece el máximo número de intentos de autenticación permitidos por conexión, es decir, la cantidad de veces que podemos equivocarnos al ingresar el usuario y/o contraseña. Una vez que los intentos alcanzan la mitad de este valor, las conexiones fallidas siguientes serán registradas. Después del máximo número de intentos se cerrará la conexión. Es posible volver a intentarlo, pero el límite de intentos por vez evita ataques basados en la persistencia de la conexión.

MaxAuthTries 5

MaxSessions – Especifica el número máximo de sesiones abiertas de shell, inicio de sesión o subsistema (por ejemplo, sftp) permitidas por conexión de red. Los clientes que soportan la multiplexación de conexiones pueden establecer múltiples sesiones. Si se establece MaxSessions a 1, se desactivará la multiplexación de sesiones, mientras que si se establece a 0, se evitarán todas las sesiones de shell, login y subsistema, a la vez que se permite el for- warding. El valor predeterminado es 10.

MaxSessions 10

Con todo esto que hemos aprendido ya puedes entrar a tu sistema remoto de la siguiente forma:

ssh -p 22343 tu_usuario@host_o_IP

Si te interesa saber mas de como proteger tu servidor, puedes ver «Instalar Fail2ban en Debian 12 y que funcione«

En Debian hay comandos que por defecto sólo están para el usuario root. Se almacenan la carpeta /sbin en vez de en /usr/bin. Por lo tanto al ejecutar un comando reservado como un usuario normal sin privilegios dará el siguiente error:   

bash: comando: orden no encontrada 

En mi caso he tenido problemas con «ssmtp» ya que cuando intentaba enviar emails desde la terminal, me devolvía un error

echo "Testing…1…2…3" | ssmtp mi_email@gmail.com
bash: ssmtp: orden no encontrada

Para solucionar esto hay que crear un enlace simbólico que apunte de la carpeta /sbin a /usr/bin

Comando ln

El comando ln en Linux es utilizado para crear enlaces simbólicos y duros. Estos enlaces son útiles cuando se necesita acceder a un archivo o directorio desde diferentes ubicaciones dentro del sistema de archivos.

Ejemplo de como crear un enlace simbólico :

ln -s /sbin/comando /usr/bin/comando

Ejemplo práctico

Enlace simbólico del comando ssmtp:

sudo ln -s /sbin/ssmtp /usr/bin/ssmtp

Ahora ya lo puedes ejecutar como un usuario normal

echo "Probando…1…2…3" | ssmtp mi_email@gmail.com

Si no quieres añadir un enlace simbólico y deseas ejecutarlo como un usuario normal solo hay que ejecutar el comando de la siguiente manera:

$ sudo echo "Probando…1…2…3" | ssmtp mi_email@gmail.com

Nota, para usar el comando ssmtp (enviar emails desde la terminal) debes de tenerlo instalado y configurado.