Sistema de archivos en Linux (FHS): qué es, cómo funciona y por qué importa

Cuando abres un explorador de archivos en Windows, ves las unidades C:\, D:\ y carpetas como Escritorio, Documentos y Descargas. En Linux la organización es completamente distinta. No hay letras de unidad. Todo cuelga de una sola raíz llamada / (barra) y cada carpeta tiene un propósito definido por un estándar internacional llamado FHS (Filesystem Hierarchy Standard). Entender esa estructura es como conocer el plano de un edificio antes de entrar: sabes dónde está cada habitación sin tener que abrir todas las puertas.

Si tu objetivo es la ciberseguridad, saber dónde guarda Linux los usuarios, las contraseñas, los registros y las configuraciones es fundamental. Gran parte de las técnicas de reconocimiento, escalada de privilegios y post-explotación consisten en leer archivos que están siempre en el mismo sitio. Un pentester que no conoce el FHS es como un cerrajero que no sabe cómo es una cerradura por dentro.

Esta lección te lleva desde cero: qué es un sistema de archivos, qué hay en cada directorio, qué archivos importan para la seguridad, cómo funcionan los inodes y qué significa «montar» un disco. Al terminar, podrás moverte por cualquier distribución Linux con confianza.

Practica siempre en sistemas propios o en entornos autorizados, como los laboratorios de whoami-labs. Acceder a archivos de un sistema ajeno sin permiso es un delito en la mayoría de países.

Qué es el sistema de archivos en Linux#

Un sistema de archivos (filesystem) es la forma en que un sistema operativo organiza los datos en un disco. Piensa en una biblioteca: los libros son los archivos, las estanterías son los directorios y el sistema de clasificación (por tema, autor, código) es el filesystem. Sin ese sistema, tendrías miles de libros apilados en el suelo sin forma de encontrar nada.

En Linux, el filesystem empieza en un solo punto: la raíz /. De ahí cuelgan todos los directorios, sin importar cuántos discos duros, particiones o unidades USB tenga el equipo. Si conectas un pendrive, no aparece como E:\ sino que se «monta» dentro de una carpeta (por ejemplo /media/usb). Todo forma un único árbol.

El Filesystem Hierarchy Standard (FHS) es un documento mantenido por la Linux Foundation que define qué debe ir en cada directorio. Gracias a él, /etc siempre contiene configuraciones, /var siempre tiene datos variables y /home siempre guarda las carpetas personales de los usuarios, da igual si usas Ubuntu, Fedora, Debian o Arch. Esa consistencia es una ventaja enorme cuando auditas un sistema desconocido: ya sabes dónde buscar.

Por qué es importante#

Para un usuario normal, conocer el FHS evita errores como borrar archivos del sistema o instalar programas en sitios donde no deberían estar. Para alguien que estudia ciberseguridad, las ventajas son mucho mayores.

Cuando consigues acceso a un sistema Linux durante un ejercicio de pentesting, lo primero que haces es reconocimiento local: revisar quién más usa el equipo, qué servicios corren, qué configuraciones están expuestas y si hay credenciales guardadas. Toda esa información está en archivos predecibles dentro del FHS. Saber que los usuarios están en /etc/passwd, que las claves SSH viven en ~/.ssh/ y que el historial de comandos se guarda en .bash_history te permite extraer datos clave en segundos, en lugar de buscar a ciegas.

Además, muchas escaladas de privilegios se basan en permisos incorrectos sobre archivos del filesystem. Un /etc/shadow legible por todos, un script en /tmp ejecutado por root mediante cron, o un binario SUID en un directorio escribible son errores de configuración que solo detectas si conoces el árbol de directorios.

Componentes principales#

El FHS define más de veinte directorios, pero estos son los que necesitas conocer desde el primer día:

Un detalle importante: /proc y /sys no existen en el disco duro. Son filesystems virtuales que el kernel genera en tiempo real. Cuando lees /proc/cpuinfo, no estás leyendo un archivo guardado: el kernel crea esa información en el momento. Es como un termómetro que te da la temperatura actual, no una lectura guardada de ayer.

Cómo funciona#

Inodes: la identidad real de un archivo#

Cuando creas un archivo en Linux, el sistema no lo identifica por su nombre, sino por un número llamado inode (index node). El inode es como el DNI del archivo: contiene su tamaño, permisos, propietario, fechas de modificación y la lista de bloques del disco donde están los datos. El nombre del archivo es solo una etiqueta que apunta al inode.

ls -i /etc/passwd
262187 /etc/passwd

Ese número (262187) es el inode. Puedes tener varios nombres apuntando al mismo inode (enlaces duros) o un nombre que apunte a otro nombre (enlace simbólico). Esto es relevante en seguridad: si un atacante crea un enlace simbólico de /tmp/config hacia /etc/shadow, un programa mal escrito podría leer el archivo de contraseñas pensando que lee un archivo temporal.

Montaje: conectar discos al árbol#

En Linux no existen letras de unidad. Para acceder al contenido de un disco, partición o dispositivo USB, tienes que montarlo en un directorio del árbol. El comando mount conecta un filesystem a un punto del árbol:

sudo mount /dev/sdb1 /mnt/usb

Después de ese comando, el contenido del pendrive aparece dentro de /mnt/usb. Para ver qué está montado:

mount | grep "^/dev"
/dev/sda1 on / type ext4 (rw,relatime)
/dev/sdb1 on /mnt/usb type vfat (rw,relatime)

El archivo /etc/fstab define qué se monta automáticamente al arrancar. Cada línea indica el dispositivo, el punto de montaje, el tipo de filesystem y las opciones:

cat /etc/fstab
# dispositivo      punto       tipo   opciones          dump fsck
/dev/sda1          /           ext4   defaults          0    1
/dev/sda2          /home       ext4   defaults          0    2
tmpfs              /tmp        tmpfs  nosuid,noexec     0    0

Fíjate en las opciones de /tmp: nosuid,noexec. Eso significa que aunque alguien ponga un binario SUID ahí, el sistema se niega a ejecutarlo con privilegios elevados. Es una medida de seguridad habitual.

Uso práctico paso a paso#

Paso 1: explorar la raíz#

Abre una terminal y lista el contenido de la raíz:

ls -l /
total 64
drwxr-xr-x   2 root root  4096 bin
drwxr-xr-x   3 root root  4096 boot
drwxr-xr-x  18 root root  3800 dev
drwxr-xr-x  92 root root  4096 etc
drwxr-xr-x   3 root root  4096 home
drwxr-xr-x  18 root root  4096 usr
drwxr-xr-x  13 root root  4096 var
drwxrwxrwt   8 root root  4096 tmp

Observa que casi todo pertenece a root. El directorio /tmp tiene una t al final de los permisos: es el sticky bit, que impide que un usuario borre archivos de otro dentro de esa carpeta.

Paso 2: leer archivos clave del sistema#

Los archivos que todo pentester revisa en los primeros segundos:

cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
ana:x:1001:1001:Ana García:/home/ana:/bin/bash

Cada línea tiene siete campos separados por : (usuario, contraseña (x = en shadow), UID, GID, nombre completo, directorio home, shell). Si la shell es /usr/sbin/nologin o /bin/false, ese usuario no puede iniciar sesión.

cat /etc/hosts
127.0.0.1   localhost
192.168.1.50 servidor-interno.local

El archivo /etc/hosts asocia nombres a direcciones IP. A veces revela nombres de máquinas internas que no aparecen en DNS.

Paso 3: buscar archivos sensibles del usuario#

ls -la /home/ana/
.bash_history
.ssh/
.profile

El archivo .bash_history contiene los últimos comandos que el usuario ejecutó. A veces incluye contraseñas escritas por error:

cat /home/ana/.bash_history
ssh [email protected]
mysql -u root -pS3cret0!
scp backup.tar.gz [email protected]:/tmp/

La carpeta .ssh/ puede contener claves privadas (id_rsa) y la lista de hosts autorizados. Una clave privada sin proteger es una puerta abierta.

Paso 4: revisar logs del sistema#

ls /var/log/
auth.log  syslog  kern.log  dpkg.log  apache2/

El archivo /var/log/auth.log (o /var/log/secure en Red Hat) registra cada intento de login, cada uso de sudo y cada conexión SSH. Es oro para un defensor y una pista para un atacante que quiere saber qué usuarios son activos.

grep "Failed password" /var/log/auth.log
Nov  5 14:22:03 server sshd: Failed password for root from 10.0.0.99

Paso 5: comprobar los montajes actuales#

df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        50G   12G   35G  26% /
tmpfs           2.0G     0  2.0G   0% /tmp
/dev/sdb1       8.0G  1.2G  6.3G  16% /mnt/datos

El comando df -h muestra los filesystems montados con su espacio. findmnt es más moderno y muestra el árbol de montajes:

findmnt --target /tmp
TARGET SOURCE  FSTYPE OPTIONS
/tmp   tmpfs   tmpfs  rw,nosuid,noexec

Qué puedes hacer con esto#

Buenas prácticas#

Aunque estas prácticas están orientadas a administradores, conocerlas te ayuda a detectar cuándo un sistema no las cumple, que es justo lo que busca un pentester.

• Monta /tmp como partición separada con las opciones nosuid,nodev,noexec. Esto impide que un atacante ejecute binarios o use archivos SUID desde /tmp.
• Protege /etc/shadow con permisos 640 (legible solo por root y el grupo shadow). Si cualquier usuario puede leerlo, puede crackear las contraseñas offline.
• Desactiva el acceso a /proc para usuarios no privilegiados en entornos sensibles con hidepid=2 en las opciones de montaje. Esto evita que un usuario vea los procesos de otro.
• Revisa periódicamente los permisos de /home. Los directorios personales deben ser 700 o 750, no 755. Un home legible por todos expone .bash_history, .ssh/ y configuraciones privadas.
• Limpia /tmp y /var/tmp de forma periódica. Los archivos temporales olvidados pueden contener datos sensibles o ser reemplazados por un atacante (ataque de enlace simbólico).
• Usa noexec en particiones que no necesitan ejecutar binarios, como /var o /home, si el caso de uso lo permite.

Errores comunes de principiante#

• Confundir / con /root: la raíz del sistema (/) es el directorio base de todo el árbol. /root es la carpeta personal del usuario root. Son cosas distintas.
• Pensar que borrar un archivo lo elimina del disco: el comando rm elimina el enlace del directorio al inode. Los datos siguen en el disco hasta que se sobreescriben. Por eso existe la recuperación forense de archivos.
• Ignorar los archivos ocultos: en Linux, cualquier archivo que empiece por punto (.bashrc, .ssh, .bash_history) está oculto para ls normal. Necesitas ls -a para verlos. Muchos principiantes no saben que existen.
• Crear archivos como root en /home: si usas sudo para crear archivos en la carpeta de un usuario, el propietario será root y el usuario no podrá modificarlos. Usa chown después o evita sudo innecesario.
• No revisar /etc/fstab antes de modificarlo: un error en /etc/fstab puede impedir que el sistema arranque. Siempre verifica la sintaxis con findmnt --verify antes de reiniciar.
• Asumir que /proc y /sys son carpetas normales: intentar copiar o hacer backup de estos directorios virtuales genera errores o archivos inútiles. Son interfaces al kernel, no datos persistentes.

Preguntas frecuentes#

Diferencia entre /bin y /usr/bin#

Históricamente, /bin contenía los binarios necesarios para arrancar y reparar el sistema (cuando /usr aún no estaba montado), mientras que /usr/bin tenía los programas de uso general. En las distribuciones modernas (Debian 12, Ubuntu 22.04, Fedora 33 en adelante), /bin es un enlace simbólico a /usr/bin y la distinción ha desaparecido en la práctica. Lo mismo ocurre con /sbin y /usr/sbin.

Puedo recuperar un archivo borrado con rm#

Depende. rm elimina la entrada del directorio pero no borra los datos del disco de inmediato. Si actúas rápido y el disco no ha sobreescrito esos bloques, herramientas forenses como extundelete o photorec pueden recuperar el contenido. Sin embargo, en un SSD con TRIM activo, la recuperación es mucho más difícil porque el disco marca los bloques como disponibles de inmediato.

Qué pasa si /tmp no tiene el sticky bit#

Sin el sticky bit, cualquier usuario podría borrar o renombrar los archivos temporales de otro usuario. Esto permitiría ataques como reemplazar un archivo temporal que un script de root va a leer con contenido malicioso. El sticky bit (la t en drwxrwxrwt) impide que alguien borre archivos que no le pertenecen.

Qué son /proc/self y /proc/PID#

/proc/self es un enlace simbólico que siempre apunta al directorio del proceso que lo lee. Si tu shell tiene PID 1234, leer /proc/self/status equivale a leer /proc/1234/status. Cada proceso tiene su propio directorio bajo /proc/ con información como su línea de comandos (cmdline), sus variables de entorno (environ), sus descriptores de archivos (fd/) y su mapa de memoria (maps). Todo esto es útil en post-explotación.

Por qué /dev/null es útil#

/dev/null es un archivo especial que descarta todo lo que le envías. Se usa para silenciar la salida de comandos que no te interesa ver. Por ejemplo, find / -name "*.conf" 2>/dev/null busca archivos .conf y envía los errores de permiso a /dev/null para que no llenen la pantalla. También existe /dev/zero (que produce ceros infinitos, útil para borrar discos) y /dev/urandom (que genera datos aleatorios para criptografía).

Resumen#

• Linux organiza todo en un árbol que empieza en /, sin letras de unidad. El FHS define qué va en cada directorio y se cumple en todas las distribuciones.
• Los directorios clave son /etc (configuraciones), /home (usuarios), /var (logs y datos variables), /tmp (temporales), /proc (información del kernel en vivo) y /dev (dispositivos).
• Cada archivo tiene un inode que almacena sus metadatos reales. El nombre es solo una etiqueta que apunta al inode.
• Montar un disco significa conectar su filesystem a un punto del árbol. /etc/fstab controla los montajes automáticos al arrancar.
• Los archivos que un pentester revisa primero son /etc/passwd, /etc/shadow, .bash_history, .ssh/ y los logs de /var/log.
• Opciones de montaje como nosuid, noexec y hidepid son defensas básicas que todo administrador debería aplicar y todo auditor debería verificar.

Fuentes y lecturas recomendadas#

• Filesystem Hierarchy Standard 3.0 (documento oficial)
• Linux man page: hier (jerarquía del sistema de archivos)
• Linux man page: inode
• Linux man page: mount
• Linux man page: fstab
• The Linux Documentation Project: Filesystem