Sistema de ficheros

Linux sigue el estándar FHS (Filesystem Hierarchy Standard) que define dónde va cada tipo de archivo. Todo el sistema de archivos cuelga de una única raíz /. Entender esta jerarquía es fundamental para administración, auditoría y pentesting, saber dónde están los archivos de configuración, los logs, los binarios y los datos de las aplicaciones ahorra mucho tiempo.

1.1. 🌳 Árbol de directorios

/
├── bin/       → binarios esenciales del sistema
├── sbin/      → binarios de administración (root)
├── lib/       → librerías de bin/ y sbin/
├── lib64/     → librerías de 64 bits
├── usr/       → programas y datos de usuario
│   ├── bin/       → binarios no esenciales
│   ├── sbin/      → binarios de admin no esenciales
│   ├── lib/       → librerías de usr/bin/
│   ├── local/     → software compilado/instalado manualmente
│   │   ├── bin/
│   │   ├── sbin/
│   │   └── lib/
│   └── share/     → datos independientes de arquitectura (docs, man, icons)
├── etc/       → configuración del sistema
├── home/      → directorios personales de usuarios
├── root/      → home del superusuario
├── var/       → datos variables (logs, bases de datos, colas, cachés)
│   ├── log/
│   ├── www/
│   ├── mail/
│   └── spool/
├── tmp/       → archivos temporales (se borran al reiniciar)
├── run/       → datos de runtime (PID files, sockets)
├── dev/       → dispositivos como archivos
├── proc/      → filesystem virtual — estado del kernel y procesos
├── sys/       → filesystem virtual — dispositivos y parámetros del kernel
├── mnt/       → puntos de montaje manuales temporales
├── media/     → puntos de montaje automáticos (USB, CD...)
├── opt/       → software de terceros autocontenido
├── srv/       → datos servidos por servicios (web, ftp, nfs...)
└── boot/      → kernel, initrd y bootloader

Enlaces simbólicos

/bin, /sbin, /lib son symlinks en sistemas modernos En Ubuntu/Debian modernos y Fedora/RHEL 7+, /bin, /sbin y /lib son symlinks hacia /usr/bin, /usr/sbin y /usr/lib. La separación histórica ya no tiene sentido con los sistemas de init modernos.

1.2. 📁 Directorio etc - configuración del sistema

Es el directorio más importante para un administrador. Contiene toda la configuración del sistema y las aplicaciones instaladas. No debe contener binarios.

Gestión de cuentas

Archivo	Descripción
`/etc/passwd`	usuarios del sistema
`/etc/shadow`	hashes de contraseñas (solo root)
`/etc/group`	grupos del sistema
`/etc/gshadow`	contraseñas de grupos
`/etc/sudoers` / `/etc/sudoers.d/`	permisos de sudo / fragmentos de sudoers

Resolución de nombres

Archivo	Descripción
`/etc/hostname`	nombre del equipo
`/etc/hosts`	resolución DNS estática
`/etc/resolv.conf`	servidores DNS
`/etc/gshadow`	contraseñas de grupos
`/etc/sudoers` / `/etc/sudoers.d/`	permisos de sudo / fragmentos de sudoers
`os-release`	información de la distribución

Shell y variables de entorno

Archivo	Descripción
`/etc/environment`	Variables de entorno del sistema
`/etc/profile`	Configuración del shell para todos los usuarios
`/etc/bash.bashrc`	Bashrc global (Debian/Ubuntu)
`/etc/shells`	Lista de shells válidos del sistema

Repositorios

Archivo	Descripción
`/etc/apt/sources.list` / `/etc/apt/sources.list.d/`	Repositorios principales / secundarios
`/etc/apt/preferences`	Prioridades de paquetes
`/etc/apt/trusted.gpg.d`	Claves GPG de repositorios

Red

Archivo	Descripción
`/etc/hosts`	Resolución estática `IP → nombre`
`/etc/resolv.conf`	Servidores DNS del sistema
`/etc/nsswitch.conf`	Orden de resolución: `files dns mymachines`
`/etc/network/interfaces`	Config de red con ifupdown (Debian legacy)
`/etc/netplan/*.yaml`	Config de red en Ubuntu moderno
`/etc/NetworkManager/system-connections/`	Perfiles de red de NetworkManager
`/etc/systemd/network/*.network`	Config de red con systemd-networkd
`/etc/iptables/rules.v4`	Reglas de iptables persistentes (IPv4)
`/etc/iptables/rules.v6`	Reglas de iptables persistentes (IPv6)

1.2. 📁 Directorio var - datos variables

Datos que cambian en tiempo de ejecución: logs, bases de datos, colas de correo, cachés.

/var/
├── log/                → logs del sistema y aplicaciones
│   ├── syslog          → log general del sistema (Debian/Ubuntu)
│   ├── messages        → log general (CentOS/RHEL)
│   ├── auth.log        → autenticaciones, sudo, SSH (Debian/Ubuntu)
│   ├── secure          → equivalente de auth.log (CentOS/RHEL)
│   ├── kern.log        → mensajes del kernel
│   ├── dmesg           → mensajes de arranque del kernel
│   ├── faillog         → intentos de login fallidos
│   ├── lastlog         → último login de cada usuario
│   ├── wtmp            → historial de logins (binario, leer con `last`)
│   ├── btmp            → intentos de login fallidos (binario, leer con `lastb`)
│   ├── nginx/          → logs de Nginx (access.log, error.log)
│   ├── apache2/        → logs de Apache
│   ├── mysql/          → logs de MySQL
│   └── journal/        → journal binario de systemd
│
├── www/                → datos de servidores web (alternativa a /srv/www)
│   └── html/           → DocumentRoot por defecto en Debian/Ubuntu
│
├── lib/                → datos persistentes de aplicaciones y servicios
│   ├── dpkg/           → base de datos de paquetes instalados (Debian/Ubuntu)
│   │   ├── info/           → scripts de instalación y listas de archivos
│   │   └── status          → estado de todos los paquetes
│   ├── rpm/            → base de datos RPM (CentOS/RHEL)
│   ├── mysql/          → datos de MySQL
│   ├── postgresql/     → datos de PostgreSQL
│   └── docker/         → imágenes y contenedores Docker
│
├── cache/              → cachés de aplicaciones (pueden borrarse)
│   ├── apt/            → paquetes descargados por APT
│   └── man/            → páginas de manual cacheadas
│
├── spool/              → colas de trabajos pendientes
│   ├── cron/           → crontabs de usuarios
│   │   └── crontabs/
│   ├── mail/           → correos locales
│   └── cups/           → colas de impresión
│
├── tmp/                → temporal persistente entre reinicios (a diferencia de /tmp)
└── backups/            → backups automáticos del sistema (dpkg, etc.)

1.3. 📁 Directorio proc - estado del kernel y procesos

Filesystem virtual en RAM. No ocupa espacio en disco.

/proc/
├── <PID>/              → directorio de cada proceso
│   ├── cmdline             → comando de arranque
│   ├── environ             → variables de entorno (separadas por \0)
│   ├── exe                 → symlink al ejecutable
│   ├── fd/                 → descriptores de archivo abiertos
│   ├── maps                → regiones de memoria
│   ├── status              → estado: UIDs, memoria, señales
│   ├── net/                → estado de red del proceso
│   └── cwd                 → directorio de trabajo (symlink)
├── cpuinfo             → información de CPUs
├── meminfo             → información de RAM y swap
├── mounts              → filesystems montados actualmente
├── net/                → estado de la red del sistema
│   ├── tcp                 → conexiones TCP activas
│   ├── udp                 → conexiones UDP
│   └── arp                 → tabla ARP
├── sys/                → parámetros del kernel (modificables via sysctl)
│   ├── kernel/
│   │   ├── hostname
│   │   ├── pid_max
│   │   └── randomize_va_space  → ASLR (0=off, 1=parcial, 2=completo)
│   └── net/
│       └── ipv4/
│           ├── ip_forward       → enrutamiento IP (0/1)
│           └── tcp_syncookies   → protección SYN flood
├── version             → versión del kernel
├── uptime              → tiempo encendido y tiempo idle
├── loadavg             → carga media (1, 5, 15 minutos)
├── filesystems         → filesystems soportados por el kernel
├── partitions          → particiones detectadas
├── swaps               → swap activa
└── modules             → módulos del kernel cargados

1.4. 📁 Directorio sys - dispositivos y parámetros del kernel

Filesystem virtual que expone la jerarquía de dispositivos y permite modificar parámetros en caliente.

/sys/
├── class/              → dispositivos agrupados por clase
│   ├── net/                → interfaces de red
│   ├── block/              → dispositivos de bloque
│   └── power/              → gestión de energía
├── bus/                → buses de hardware (PCI, USB...)
├── devices/            → árbol completo de dispositivos
├── fs/                 → parámetros de filesystems
│   └── cgroup/             → jerarquía de cgroups
├── kernel/             → parámetros del kernel en caliente
│   └── security/           → módulos de seguridad (SELinux, AppArmor)
└── module/             → parámetros de módulos del kernel cargados

1.5. 📁 Directorio dev - dispositivos como archivos

En Linux, los dispositivos son archivos. Todo en /dev es una interfaz hacia hardware o dispositivos virtuales.

/dev/
├── sda, sdb...         → discos duros / SSDs SATA
├── nvme0n1...          → discos NVMe
├── vda, vdb...         → discos virtuales (VMs)
├── sda1, sda2...       → particiones
├── sr0                 → lector CD/DVD
├── tty                 → terminal actual
├── tty0..63            → terminales virtuales (consolas)
├── pts/                → pseudoterminales (SSH, tmux, xterm)
│   └── 0, 1, 2...
├── stdin → /proc/self/fd/0   → entrada estándar
├── stdout → /proc/self/fd/1  → salida estándar
├── stderr → /proc/self/fd/2  → salida de errores
├── null                → agujero negro (descarta todo lo escrito)
├── zero                → fuente de bytes \0 infinitos
├── random              → bytes aleatorios (bloquea si no hay entropía)
├── urandom             → bytes aleatorios (no bloquea, menos seguro)
├── mem                 → memoria física del sistema (acceso directo)
├── kmem                → memoria del kernel
├── loop0..7            → dispositivos de bucle (para montar imágenes)
└── mapper/             → dispositivos de device mapper (LVM, LUKS)
    ├── ubuntu--vg-ubuntu--lv  → volumen LVM
    └── sda5_crypt             → volumen LUKS

1.6. 📁 Directorios personales

/home/<usuario>/
├── .bashrc             → configuración del shell bash (interactivo no-login)
├── .bash_profile       → configuración del shell bash (login)
├── .bash_logout        → ejecutado al cerrar sesión
├── .bash_history       → historial de comandos ⚠️ puede contener contraseñas
├── .profile            → configuración genérica (sh, bash, dash)
├── .ssh/               → claves y configuración SSH del usuario
├── .gnupg/             → claves GPG del usuario
├── .config/            → configuración de aplicaciones (XDG)
├── .local/             → datos locales de aplicaciones (XDG)
│   ├── share/
│   └── bin/            → binarios de usuario (en PATH en distros modernas)
├── .cache/             → cachés de aplicaciones (se puede borrar)
├── .env                → variables de entorno de proyectos ⚠️ puede contener secretos
├── .netrc              → credenciales para FTP/HTTP ⚠️ en texto claro
├── .mysql_history      → historial de MySQL ⚠️ puede contener contraseñas
└── .psql_history       → historial de PostgreSQL

1.7. 📁 Directorio boot - arranque del sistema

/boot/
├── vmlinuz-<versión>           → kernel comprimido
├── initrd.img-<versión>        → initramfs (sistema de archivos inicial en RAM)
├── config-<versión>            → configuración con la que se compiló el kernel
├── System.map-<versión>        → tabla de símbolos del kernel
└── grub/                       → configuración del bootloader GRUB
    ├── grub.cfg                    → config generada automáticamente (no editar)
    └── grub.d/                     → fragmentos de config de GRUB

Editar GRUB

Nunca editar grub.cfg directamente. Editar /etc/default/grub y ejecutar update-grub (Debian/Ubuntu) o grub2-mkconfig (RHEL/Fedora).

2. 🔑 Permisos y capacidades

2.1. Permisos Unix (DAC)

Linux usa un modelo de control de acceso discrecional (DAC) basado en tres entidades y tres tipos de permiso:

-rwxr-xr--  1  jessica  developers  4096  may 12  archivo.sh
│└──┘└──┘└──┘
│  │   │   └── otros (others)
│  │   └────── grupo propietario
│  └────────── propietario (user)
└───────────── tipo: - archivo / d directorio / l symlink

Permiso	Permiso numérico	Archivo	Directorio
`r`	+4	Leer contenido	Listar contenido (`ls`)
`w`	+2	Modificar contenido	Crear/eliminar archivos dentro
`x`	+1	Ejecutar	Entrar al directorio (`cd`)

Los permisos se pueden asignar de modo letra para cada uno separado (Ej. chmod u+x, el propietario puede ejecutarlo) o por número (Ej. chmod 777, todo el mundo tiene permiso de todo)

Luego tenemos los bits especiales

Bit	Sobre ejecutable	Sobre directorio
SUID (`s` en user, `4xxx`)	Se ejecuta con el UID del propietario, no del invocador.	Sin efecto especial
SGID (`s` en group, `2xxx`)	Se ejecuta con el GID del propietario	Archivos nuevos heredan el grupo del directorio
Sticky (`t` en others, `1xxx`)	Sin efecto especial	Solo el propietario puede borrar sus archivos (ej: `/tmp`)

⚠️ Si un binario tiene SUID y pertenece a root, cualquier usuario puede ejecutarlo con privilegios de root.

2.2. ACLs (Access Control Lists)

Las ACLs extienden el modelo Unix clásico permitiendo permisos por usuario concreto sobre un archivo, sin cambiar el propietario ni el grupo.

Acción	Comando
Ver ACLs de un archivo	`getfacl archivo.txt`
Dar permisos a un usuario/grupo concreto	`setfacl -m u:jessica:r archivo.txt` (grupo `g:developers:rw`)
Eliminar ACL de un usuario	`setfacl -x u:jessica archivo.txt`
Eliminar todas las ACLs	`setfacl -b archivo.txt`

2.3. Capabilities — el equivalente a privilegios Windows

Las capabilities dividen los privilegios de root en unidades más pequeñas, permitiendo dar a un proceso una capacidad específica sin darle UID 0.

Capability	Permite	Riesgo
`cap_setuid`	Cambiar el UID del proceso a cualquier valor, incluyendo 0	🔴 Escalada directa a root
`cap_sys_admin`	Casi equivalente a root: montar filesystems, namespaces, ptrace...	🔴 Muy alto
`cap_sys_ptrace`	Depurar y acceder a la memoria de cualquier proceso	🔴 Alto
`cap_dac_read_search`	Leer cualquier archivo ignorando permisos	🔴 Alto
`cap_net_raw`	Crear sockets raw (sniffing, spoofing)	🟡 Medio
`cap_net_bind_service`	Bind a puertos < 1024 sin ser root	🟢 Bajo (legítimo)
`cap_sys_module`	Cargar módulos del kernel → rootkit	🔴 Crítico
`cap_chown`	Cambiar el propietario de cualquier archivo	🔴 Alto

Por tanto tenemos estos comandos para gestionarlas:

Acción	Comando
Ver capabilities de un binario	`getcap /usr/bin/python3`
Ver todos los binarios con capabilities en el sistema	`getcap -r / 2>/dev/null`
Asignar capability a un binario	`setcap cap_net_raw+ep /usr/bin/ping`

Capabilities en binarios interpretados

Si un intérprete como Python o Ruby tiene cap_setuid, cualquier script que ejecute puede cambiar su UID a 0 y obtener una shell root. Es una de las técnicas de escalada más silenciosas.

Ej python, con cap_setuid → python3 -c "import os; os.setuid(0); os.system('/bin/bash')"

2.4. Atributos extendidos

El sistema de ficheros de Linux permite además activar ciertos atributos especiales. Estos se listan con lsattr <archivo>

Para cambiar estos permisos especiales se utiliza sudo chattr +i archivo.txt (para hacerlo inmutable).

Atributos comunes:

i (Inmutable): El archivo no puede ser modificado, eliminado, renombrado ni enlazado. Ni siquiera por root.
a (Append Only): El archivo solo puede abrirse en modo escritura para añadir información.