¿Cómo crear listas de control de acceso y cuotas de disco en Linux?

Los permisos Unix (rwx para usuario, grupo y otros) cubren la mayoría de los casos, pero presentan limitaciones cuando se necesita otorgar acceso selectivo a varios usuarios o grupos sin cambiar el propietario o grupo principal del archivo.

## 17.1. Introducción: más allá de los permisos tradicionales

Las **ACL (Access Control Lists)** extienden este modelo permitiendo definir permisos específicos para múltiples usuarios y grupos de forma independiente.

Por otro lado, en entornos multiusuario es crucial limitar la cantidad de espacio en disco que cada usuario o grupo puede consumir. Las **cuotas de disco** permiten establecer límites de almacenamiento y número de archivos (inodos), con mecanismos de advertencia y bloqueo.

Ambos conceptos son evaluados en el examen LFCS, por lo que debes dominar su configuración, gestión y resolución de problemas.

—

## Parte I: Listas de Control de Acceso (ACL)

### 17.2. ¿Qué son las ACL y por qué son necesarias?

Imagina que tienes un proyecto donde el archivo `informe.txt` es propiedad de `juan` con grupo `desarrollo`.

Los permisos clásicos permiten dar acceso a:

– **juan** (propietario): lectura y escritura.
– **grupo desarrollo**: solo lectura.
– **otros**: sin acceso.

Pero ¿Qué pasa si `maria`, que no pertenece al grupo `desarrollo`, necesita editar el archivo? Con permisos tradicionales tendrías que cambiar el grupo del archivo (afectando a todos), añadir a `maria` al grupo (dándole acceso a otros recursos del grupo) o modificar los permisos de “otros” (inseguro).

Las ACL resuelven esto permitiendo asignar a `maria` permisos de escritura específicos sin alterar los permisos base.

### 17.3. Soporte del sistema de archivos

Las ACL se soportan de forma nativa en ext2/3/4, XFS, Btrfs, etc. En la mayoría de sistemas modernos ya está habilitado por defecto. Para verificar si una partición tiene soporte de ACL, se puede intentar montar con la opción `acl` (aunque en ext4/XFS está implícita).

Comprobación rápida:

“`bash
tune2fs -l /dev/sda1 | grep “Default mount options”
“`

Si no aparece `acl`, se puede añadir en `/etc/fstab`:

“`
UUID=… / ext4 defaults,acl 0 1
“`

En XFS, las ACL están siempre activas.

### 17.4. Herramientas: `getfacl` y `setfacl`

– **`getfacl`**: muestra las ACL de un archivo o directorio.
– **`setfacl`**: modifica las ACL.

#### 17.4.1. Ver ACL con `getfacl`

“`bash
getfacl archivo.txt
“`

Salida típica:

“`
# file: archivo.txt
# owner: juan
# group: desarrollo
user::rw-
user:maria:rw-
group::r–
group:auditores:r–
mask::rw-
other::r–
“`

– Las primeras líneas (`#`) indican nombre, propietario y grupo.
– `user::rw-`: permisos del propietario (equivale al permiso clásico del usuario).
– `user:maria:rw-`: ACL específica para el usuario `maria`.
– `group::r–`: permisos del grupo propietario.
– `group:auditores:r–`: ACL específica para el grupo `auditores`.
– `mask::rw-`: máscara efectiva (explicada más abajo).
– `other::r–`: permisos para otros.

#### 17.4.2. Modificar ACL con `setfacl`

Sintaxis general:

“`bash
setfacl [opciones] regla archivo
“`

Reglas:

– `u:usuario:permisos`: asignar permisos a un usuario.
– `g:grupo:permisos`: asignar permisos a un grupo.
– `m:permisos`: establecer la máscara.
– `o:permisos`: modificar los permisos de “otros”.
– `d:regla`: ACL por defecto (solo directorios).

Permisos: combinación de `r`, `w`, `x`, o `-` para denegar.

Opciones comunes:

– `-m`: modificar (añadir o cambiar).
– `-x`: eliminar una regla.
– `-b`: eliminar todas las ACL extendidas (dejar solo las básicas).
– `-R`: recursivo.
– `-k`: eliminar todas las ACL por defecto.
– `–set`: reemplazar toda la ACL por la especificada.

**Ejemplos**:

1. Dar a `maria` permisos de lectura y escritura:

“`bash
setfacl -m u:maria:rw archivo.txt
“`

2. Dar al grupo `auditores` permiso de lectura:

“`bash
setfacl -m g:auditores:r archivo.txt
“`

3. Eliminar la ACL específica de `maria`:

“`bash
setfacl -x u:maria archivo.txt
“`

4. Eliminar todas las ACL extendidas:

“`bash
setfacl -b archivo.txt
“`

### 17.5. ACL por defecto (default ACL)

Solo los directorios pueden tener ACL por defecto. Estas se aplican automáticamente a los archivos y subdirectorios creados dentro de dicho directorio.

“`bash
setfacl -d -m u:maria:rwx /proyecto
“`

Esto hace que cualquier archivo o subdirectorio creado dentro de `/proyecto` herede la ACL de `maria` con rwx (aunque luego puede ser modificada individualmente). La ACL por defecto no afecta a los archivos ya existentes; solo a los nuevos.

### 17.6. La máscara (mask) y permisos efectivos

La máscara limita los permisos máximos que pueden tener las ACL de usuarios (excepto el propietario) y grupos. Es un mecanismo de seguridad para evitar que una ACL otorgue más permisos de los que el administrador pretende.

Por ejemplo, si la máscara es `rw-`, entonces una ACL de usuario con `rwx` solo tendrá efecto `rw-`. Al mostrar ACL, los permisos efectivos aparecen con un comentario `#effective:rw-`.

La máscara se calcula automáticamente como la unión de todos los permisos de usuarios y grupos (excepto el propietario y otros), pero se puede fijar manualmente con:

“`bash
setfacl -m m:rx archivo.txt
“`

Esto reduciría todos los permisos de usuario y grupo a como máximo `rx`.

**Importante**: si se añade una ACL nueva, la máscara puede cambiar automáticamente para acomodar los permisos otorgados (a menos que se fije con `setfacl -m m:…`).

### 17.7. Copiar ACL entre archivos

Se puede exportar e importar ACL:

“`bash
getfacl archivo1.txt > acl.txt
setfacl –restore=acl.txt # aplica a los archivos descritos en el archivo
“`

O usar `–set-file` para copiar ACL de un archivo de referencia:

“`bash
getfacl archivo1.txt | setfacl –set-file=- archivo2.txt
“`

### 17.8. ACL en scripts y en `ls`

El comando `ls -l` muestra un `+` al final de los permisos si el archivo tiene ACL extendida.

“`bash
-rw-rw-r–+ 1 juan desarrollo 1024 sep 10 10:00 archivo.txt
“`

—

## Parte II: Cuotas de disco

### 17.9. ¿Qué son las cuotas de disco?

Las cuotas permiten limitar la cantidad de bloques (espacio) y/o inodos (número de archivos) que un usuario o grupo puede utilizar en un sistema de archivos. Se basan en dos tipos de límites:

– **Límite suave (soft)**: el usuario puede excederlo temporalmente durante un período de gracia (por defecto 7 días). Al final del período, el límite suave se convierte en duro.
– **Límite duro (hard)**: el usuario no puede superarlo bajo ningún concepto. Es el máximo absoluto.

Se pueden definir cuotas para usuarios y grupos, y se aplican por sistema de archivos, no globalmente.

### 17.10. Activar cuotas en un sistema de archivos

#### 17.10.1. Paso 1: Montar con opciones de cuota

Editar `/etc/fstab` y añadir las opciones `usrquota` y/o `grpquota` según se necesite.

Ejemplo para `/home` (ext4):

“`
UUID=xxxx /home ext4 defaults,usrquota,grpquota 0 2
“`

Para XFS, se usan las opciones `uquota,gquota` (o `usrquota,grpquota` en versiones modernas). Además, XFS no usa archivos de cuota separados; integra la información en el sistema de archivos.

Después de editar, remontar:

“`bash
sudo mount -o remount /home
“`

O reiniciar.

#### 17.10.2. Paso 2: Crear archivos de cuota (solo ext3/4)

En ext4, se deben crear los archivos `aquota.user` y `aquota.group` en la raíz del sistema de archivos, y luego inicializarlos con `quotacheck`.

“`bash
sudo quotacheck -cug /home
“`

– `-c`: crear archivos de cuota si no existen.
– `-u`: usuario.
– `-g`: grupo.

Esto crea `aquota.user` y `aquota.group` en `/home`.

#### 17.10.3. Paso 3: Activar cuotas

“`bash
sudo quotaon /home
“`

Para desactivar: `sudo quotaoff /home`.

En XFS, `quotacheck` no es necesario, ya que la información de cuotas está integrada; solo se monta con opciones y se activa con `quotaon` (aunque a veces se usa `xfs_quota`).

### 17.11. Establecer cuotas

#### 17.11.1. Usando `edquota`

`edquota` abre un editor para definir los límites de un usuario o grupo.

“`bash
sudo edquota -u juan
“`

El editor mostrará algo como:

“`
Disk quotas for user juan (uid 1001):
Filesystem blocks soft hard inodes soft hard
/dev/sda1 12 0 0 3 0 0
“`

– `blocks`: uso actual de bloques (1 KB por bloque normalmente).
– `inodes`: número actual de archivos.
– `soft` y `hard` están a 0 (sin límite). Se editan los valores deseados.

Por ejemplo, para limitar a 500 MB (500000 bloques de 1 KB) con soft 450000:

“`
blocks: 450000 500000
inodes: 10000 12000
“`

Guardar y salir.

También se puede usar con `-g` para grupos.

#### 17.11.2. Usando `setquota` (no interactivo)

“`bash
sudo setquota -u juan 450000 500000 10000 12000 /home
“`

Sintaxis: `setquota -u usuario soft_blocks hard_blocks soft_inodes hard_inodes filesystem`

Para grupos: `setquota -g grupo …`.

#### 17.11.3. Período de gracia

Se puede modificar con `edquota -t`:

“`bash
sudo edquota -t
“`

Se puede establecer un período de gracia para bloques y para inodos (ej. 7 days, 1 week, 3600 seconds).

### 17.12. Verificar cuotas y uso

El comando **`quota`**: muestra el uso y límites del usuario que lo ejecuta.

“`bash
quota
“`

El comando **`repquota`**: reporta cuotas de todos los usuarios/grupos en un sistema de archivos.

“`bash
sudo repquota -a # todos los sistemas de archivos con cuotas
sudo repquota -u /home
“`

Con el comando compuesto **`quota -u juan`**: se muestra cuota de un usuario específico (requiere root para ver otros).

Con el comando **`xfs_quota`**: para XFS, reporte con `sudo xfs_quota -x -c ‘report -h’ /home`.

### 17.13. Comprobación y mantenimiento

El comando **`quotacheck`**: verifica y repara los archivos de cuota. Debe ejecutarse con el sistema de archivos desmontado o en modo solo lectura. Normalmente se hace automáticamente en el arranque.

“`bash
sudo quotacheck -avug
“`

– **`warnquota`**: envía avisos por correo a usuarios que exceden el límite suave. Se configura en `/etc/warnquota.conf` y se puede programar con cron.

### 17.14. Cuotas en entornos de red (NFS)

Las cuotas se aplican en el servidor NFS, no en el cliente. El servidor debe tener las cuotas habilitadas y configuradas en el sistema de archivos exportado. El cliente simplemente verá “No space left on device” cuando se supere el límite.

—

## 17.15. Ejercicios prácticos

### ACL

1. Crea un archivo `documento.txt` y otorga a un usuario `ana` permisos de lectura y escritura sin modificar propietario/grupo. Verifica con `getfacl`.

2. Crea un directorio `compartido` con ACL por defecto que dé al grupo `proyecto` permisos `rwx`. Crea un archivo dentro y comprueba que hereda la ACL. Luego elimina la ACL por defecto.

3. Copia las ACL de un archivo a otro usando `getfacl` y `setfacl –set-file`.

4. Establece una máscara `r` en un archivo con ACL de usuario `rw`. Observa cómo los permisos efectivos cambian.

5. Elimina todas las ACL extendidas de un archivo y comprueba que vuelve a los permisos básicos.

### Cuotas

1. En un sistema de archivos de prueba (puede ser un archivo montado con loop device o una partición extra), activa cuotas de usuario y grupo. Crea un usuario de prueba y establece un límite suave de 10 MB y duro de 15 MB. Crea archivos hasta superar el suave; observa el comportamiento. Ajusta el período de gracia a 1 minuto y espera a que se convierta en duro.

2. Usa `repquota` para ver todos los límites. Prueba `quota -u usuario` y `quota` como el propio usuario.

3. Desactiva cuotas con `quotaoff`, desmonta, verifica con `quotacheck`, y reactiva.

4. Configura cuotas en XFS (si dispones de un sistema XFS) usando `xfs_quota`. Establece un límite de inodos.

## 17.16. Resumen y consejos para LFCS

**ACL**:

– `setfacl -m u:usuario:permisos archivo` para añadir permisos.
– `setfacl -x u:usuario archivo` para eliminar.
– `getfacl` para ver.
– Las ACL por defecto con `-d` en directorios.
– La máscara limita los permisos efectivos.

**Cuotas**:

– Opciones de montaje `usrquota,grpquota` (o `uquota,gquota` en XFS).
– `quotacheck -cug /sistema` para inicializar.
– `quotaon` / `quotaoff`.
– `edquota -u usuario` o `setquota` para límites.
– `repquota`, `quota` para monitorear.
– Período de gracia con `edquota -t`.

En el examen, es probable que te pidan activar cuotas para un usuario y verificar que se aplican, o configurar ACL específicas. Practica en un entorno de laboratorio. Recuerda que las cuotas en ext4 requieren archivos de cuota; en XFS no. Esto es una diferencia clave que debes recordar.

—

Con este capítulo has ampliado tu control sobre el acceso y los recursos. En el próximo capítulo nos adentraremos en la configuración de servicios de red como NFS, Apache, Squid+SquidGuard, Postfix+Dovecot, donde aplicarás muchos de estos conceptos.