Usuarios y grupos

1. Un sistema para muchos

Unix nació en una época en que una computadora costaba lo que un edificio y la compartían decenas de personas, cada una desde su terminal y todas a la vez. De esa situación viene un rasgo que Linux conserva en su núcleo: es un sistema multiusuario. Fue diseñado desde el primer día para que varias personas lo usen simultáneamente sin estorbarse ni espiarse.

Hoy la mayoría de los equipos tiene una sola persona delante, y aun así el diseño sigue siendo útil, por razones que ya no dependen de cuánta gente haya:

La tercera fila es la que hace que un equipo personal tenga decenas de usuarios aunque lo use una sola persona, como veremos enseguida.

2. Qué es un usuario

Un usuario es una identidad con la que se ejecutan programas y a la que pertenecen archivos. Tiene un nombre, para las personas, y un número, el UID (user identifier), que es lo que el sistema usa realmente.

Un usuario no es necesariamente una persona. Es una cuenta: puede corresponder a alguien que se sienta a trabajar, o a un programa que funciona solo. El comando más simple para saber con qué identidad se está trabajando lo usamos en la primera sesión:

$ whoami
ana
$ id -u                             # el número
1000

La relación entre el nombre y el número es la clave para entender todo el tema. El kernel no sabe nada de nombres. En el inodo de un archivo, que estudiamos en el tema 14, el dueño está anotado como un número; un proceso lleva también un número. Los nombres existen solo para comodidad nuestra, y los comandos los obtienen consultando una tabla.

$ ls -l notas.txt                   # con los nombres traducidos
-rw-rw-r-- 1 ana ana 18 oct 12 10:32 notas.txt
$ ls -n notas.txt                   # lo que está guardado de verdad
-rw-rw-r-- 1 1000 1000 18 oct 12 10:32 notas.txt

La opción -n, de numeric, muestra los números sin traducir. Dos consecuencias prácticas salen de aquí. Cambiar el nombre de un usuario no afecta a sus archivos, porque el número no cambia. Y un disco llevado a otra máquina muestra dueños distintos, o solo números: los archivos dicen «1000», y en el otro equipo ese número puede corresponder a otra cuenta, o a ninguna.

3. Tres clases de usuarios

Todos los usuarios son iguales en estructura. Por convención, el rango de su UID indica para qué sirve cada uno:

Lo que hace especial a root no es su nombre, sino su número. El kernel trata de manera distinta al UID 0, y a ningún otro. Una cuenta llamada de otro modo pero con UID 0 tendría los mismos poderes.

Ese poder sin límites es la razón por la que no se trabaja como root, y por la que en Ubuntu ni siquiera se puede iniciar sesión con esa cuenta: las tareas de administración se hacen desde un usuario común, pidiendo el privilegio para un comando por vez con sudo. Es el tema 19.

4. id: quién soy para el sistema

whoami responde con un nombre. La respuesta completa, tal como la ve el sistema, la da id:

$ id
uid=1000(ana) gid=1000(ana) groups=1000(ana),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),100(users),114(lpadmin)

uid=1000(ana) gid=1000(ana) groups=1000(ana),4(adm),24(cdrom),27(sudo),…
│             │             │
│             │             └─ todos los grupos a los que pertenece
│             └─ el grupo primario
└─ el usuario: su número y, entre paréntesis, su nombre

Esas tres cosas —un UID, un GID principal y una lista de grupos— son la identidad con la que corre cada programa que ejecutas. Cuando intentas abrir un archivo, el kernel compara esa identidad con el dueño, el grupo y los permisos del archivo, y decide. Esa comparación es el tema siguiente.

$ groups
ana adm cdrom sudo dip plugdev users lpadmin
$ id root
uid=0(root) gid=0(root) groups=0(root)
$ id www-data
uid=33(www-data) gid=33(www-data) groups=33(www-data)

5. Los grupos

Dar permisos usuario por usuario sería impracticable. Para otorgarlos a varios a la vez existen los grupos.

Un grupo es un conjunto de usuarios, identificado por un nombre y un número, el GID (group identifier). Sirve para conceder un mismo acceso a todos sus miembros.

El mecanismo es simple. Cada archivo tiene, además de un dueño, un grupo, y permisos separados para ese grupo. Si un directorio pertenece al grupo contabilidad y este tiene permiso de escritura, todos sus miembros pueden trabajar allí. Incorporar a alguien al equipo es agregarlo al grupo, sin tocar un solo archivo.

Cada usuario pertenece a uno o más grupos, y uno de ellos es especial:

Ahora se explica el ana ana de todos los listados. La primera palabra es el usuario dueño; la segunda, el grupo. Y se llaman igual por una política de Ubuntu, Debian y la mayoría de las distribuciones actuales: al crear un usuario se crea también un grupo con su mismo nombre, del que es el único miembro, y se le asigna como primario. Se lo llama grupo privado de usuario.

La razón es prudencia. Los archivos nuevos reciben el grupo primario de quien los crea. Si todos los usuarios compartieran un grupo primario, como ocurría en los sistemas antiguos con el grupo users, cada archivo nacería accesible a todos los compañeros. Con un grupo privado, lo que creas nace reservado para ti, y compartir es una decisión explícita.

6. Los grupos que encontrarás

Los grupos secundarios de la salida de id no son decorativos: cada uno otorga una capacidad concreta. Estos son los habituales en un Ubuntu de escritorio:

El primer usuario, el que se crea durante la instalación, queda en todos ellos. Los que se agreguen después son, por defecto, usuarios sin privilegios: solo tienen su grupo privado. La diferencia entre «administrador» y «usuario estándar» que muestran las pantallas de configuración es, por debajo, la pertenencia al grupo sudo.

Algunos programas crean su propio grupo al instalarse y funcionan de la misma manera: quien está en el grupo, puede. El caso más conocido es docker.

7. /etc/passwd: la lista de usuarios

La tabla que relaciona nombres con números es un archivo de texto, que conocimos de nombre en el tema 8. Cada línea describe un usuario:

$ head -n 3 /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
$ wc -l /etc/passwd
46 /etc/passwd

Cuarenta y seis usuarios en un equipo que usa una sola persona: casi todos son cuentas de sistema. Cada línea tiene siete campos separados por dos puntos. La de nuestra usuaria:

ana:x:1000:1000:Ana García,,,:/home/ana:/bin/bash
│   │ │    │    │             │         │
│   │ │    │    │             │         └─ shell de inicio
│   │ │    │    │             └─ directorio personal
│   │ │    │    └─ nombre completo y datos de contacto
│   │ │    └─ GID del grupo primario
│   │ └─ UID
│   └─ contraseña: una x indica que está en /etc/shadow
└─ nombre de usuario

Varias cosas que dimos por sabidas salen de esta línea. El valor de la virgulilla, del tema 6, es el sexto campo. La shell que recibimos al abrir una terminal, del tema 1, es el séptimo; el comando chsh lo modifica. Y la forma ~usuario funciona porque la shell busca a ese usuario aquí.

El séptimo campo distingue además a las cuentas con las que se puede trabajar de las que no:

Las cuentas de sistema tienen nologin: existen para ser dueñas de archivos y de procesos, no para que alguien entre con ellas.

8. La x y /etc/shadow

El archivo se llama passwd porque en su origen contenía las contraseñas, en el segundo campo. Ya no. Hay una razón, y se ve en los permisos:

$ ls -l /etc/passwd /etc/shadow
-rw-r--r-- 1 root root   2847 oct  5 09:12 /etc/passwd
-rw-r----- 1 root shadow 1523 oct  5 09:12 /etc/shadow
$ cat /etc/shadow
cat: /etc/shadow: Permission denied

/etc/passwd tiene que ser legible por todos. Cualquier programa necesita consultarlo: ls -l para traducir los números a nombres, la shell para resolver una virgulilla. Tener allí las contraseñas, aunque estuvieran cifradas, permitía a cualquier usuario copiarlas y probar combinaciones con calma.

La solución fue separar. Los datos públicos quedaron en passwd; los secretos pasaron a otro archivo, /etc/shadow, que solo puede leer el administrador. La x es la marca de esa mudanza: «la contraseña está en el otro archivo».

Las contraseñas no se guardan tal como se escriben, ni siquiera en shadow. Se guarda el resultado de aplicarles una función de un solo sentido, un hash: es fácil calcularlo a partir de la contraseña e inviable hacer el camino inverso. Al iniciar sesión, el sistema transforma lo que escribes y compara los resultados. Nadie, tampoco el administrador, puede leer tu contraseña.

9. /etc/group: la lista de grupos

Los grupos tienen su archivo, con una estructura parecida y más corta:

sudo:x:27:ana
│    │ │  │
│    │ │  └─ miembros, separados por comas
│    │ └─ GID
│    └─ contraseña de grupo: en la práctica no se usa
└─ nombre del grupo

El cuarto campo tiene una particularidad que confunde. Lista a los usuarios que tienen este grupo como secundario. Los que lo tienen como primario no figuran, porque esa relación ya está anotada en /etc/passwd:

$ getent group ana sudo adm
ana:x:1000:
sudo:x:27:ana
adm:x:4:syslog,ana

El grupo ana aparece sin miembros, y sin embargo ana pertenece a él: es su grupo primario, como dice el cuarto campo de su línea en passwd. Para saber de verdad a qué grupos pertenece alguien no hay que leer este archivo a ojo: hay que preguntarle a id, que junta las dos fuentes.

10. getent: consultar sin abrir archivos

En el ejemplo anterior apareció un comando nuevo. getent, de get entries, consulta las bases de datos de usuarios y grupos y devuelve las líneas pedidas:

$ getent passwd ana
ana:x:1000:1000:Ana García,,,:/home/ana:/bin/bash
$ getent passwd 33
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin

Es preferible a leer los archivos directamente por dos razones. Busca por nombre o por número exactos, sin las coincidencias parciales que daría un filtro de texto. Y, sobre todo, pregunta al sistema y no a un archivo. En una empresa o una universidad, las cuentas no están en el /etc/passwd de cada máquina sino en un servidor central; getent las encuentra igual, porque usa el mismo mecanismo que el resto del sistema.

11. Quién está conectado

Una cosa son las cuentas que existen y otra quiénes tienen una sesión abierta en este momento. En un equipo personal la respuesta es obvia; en un servidor, es de las primeras cosas que se miran al entrar.

$ who
ana      tty2         2026-10-12 09:04 (tty2)
luis     pts/1        2026-10-12 11:47 (192.168.1.25)
$ w
 15:42:10 up  6:40,  2 users,  load average: 0,08, 0,05, 0,01
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
ana      tty2     -                09:04    6:38m  0.02s  0.02s /usr/libexec/gnome-session-binary
luis     pts/1    192.168.1.25     11:47    2:10   0.05s  0.01s vim informe.txt

La columna del origen distingue las sesiones locales de las remotas: luis entró desde otro equipo, cuya dirección figura entre paréntesis. La segunda columna es la terminal, uno de los archivos de /dev que vimos en el tema 8.

last es una herramienta de auditoría básica: muestra quién entró, desde dónde, cuándo y por cuánto tiempo, y también los reinicios del sistema.

$ last -n 3
luis     pts/1        192.168.1.25     Mon Oct 12 11:47   still logged in
ana      tty2         tty2             Mon Oct 12 09:04   still logged in
reboot   system boot  6.8.0-45-generic Mon Oct 12 09:02   still running

En un escritorio, las ventanas de terminal que abras pueden no figurar en who: lo que se registra es la sesión gráfica, y las ventanas dependen de ella.

12. Usuarios, archivos y procesos

Los usuarios importan porque todo lo que hay en el sistema está asociado a alguno. Dos asociaciones sostienen el modelo completo de seguridad:

El recorrido es una cadena de herencias. Al iniciar sesión, el sistema arranca tu shell con tu identidad. Cada comando que ejecutas es un proceso iniciado por la shell, y la hereda. Cada archivo que ese proceso crea queda con tu UID y tu grupo primario. Por eso todo lo que hiciste en ~/practica es de ana.

$ ps -o user,pid,cmd
USER         PID CMD
ana         3187 bash
ana         5230 ps -o user,pid,cmd

ps lista procesos; lo estudiamos en el tema 32. Aquí muestra que la shell y el comando recién lanzado corren como ana.

Cuando un proceso quiere abrir un archivo, el kernel compara las dos anotaciones: la identidad del proceso contra el dueño, el grupo y los permisos del archivo. No interviene quién está sentado al teclado, ni qué programa es, ni la intención. Solo los números. Un programa malicioso que ejecutes tiene exactamente tus permisos, ni más ni menos.

Queda una curiosidad que se entiende con lo anterior. Si se elimina una cuenta, sus archivos no desaparecen: quedan con un UID que ya no figura en ninguna tabla, y ls -l muestra el número donde antes mostraba el nombre. Son los archivos «huérfanos» que find -nouser, del tema 10, permite localizar.

13. Por qué los servicios tienen usuario

Ahora se puede explicar por qué hay decenas de cuentas en un equipo personal. Cada servicio importante tiene la suya:

La idea que hay detrás tiene nombre: el principio de mínimo privilegio. Cada programa debe tener los permisos estrictamente necesarios para su tarea, y ninguno más. Un servidor web necesita leer las páginas que publica; no necesita leer tu directorio personal, ni modificar /etc. Como corre con una identidad propia, los permisos habituales de los archivos lo limitan como a cualquier usuario.

El beneficio aparece cuando algo sale mal. Un atacante que logra controlar el servidor web obtiene los permisos de www-data: los de ese servicio, y nada más. Si el servidor corriera como root, obtendría el equipo entero. Es la misma razón por la que tú no trabajas como root.

14. Los grupos se leen al iniciar sesión

Hay un comportamiento que sorprende a todos la primera vez, y que se entiende con la sección 12. La identidad de un proceso se fija cuando el proceso arranca. Tu shell recibió su lista de grupos al iniciar la sesión, y la conserva.

Si después un administrador te agrega a un grupo, el cambio se anota en /etc/group de inmediato, pero tu shell, que ya estaba en marcha, sigue con la lista anterior. Los dos comandos muestran la diferencia:

Con esto queda presentado el reparto. El bloque sigue así:

Y la referencia del tema:

15. Resumen

• Linux es multiusuario por diseño. La separación en usuarios protege al sistema, a los usuarios entre sí y aísla los servicios.
• Un usuario es una identidad con un nombre y un número, el UID. El sistema trabaja con el número; el nombre es una traducción.
• Hay tres clases: root, con UID 0 y sin restricciones; los usuarios de sistema, del 1 al 999, para los servicios; y los comunes, desde el 1000.
• id muestra la identidad completa: UID, grupo primario y todos los grupos.
• Un grupo es un conjunto de usuarios con un GID. Cada usuario tiene un grupo primario, que reciben los archivos que crea, y puede tener varios secundarios.
• En Ubuntu cada usuario tiene un grupo privado con su mismo nombre, y por eso los listados muestran ana ana.
• La pertenencia a un grupo otorga capacidades. El grupo sudo permite actuar como administrador.
• /etc/passwd tiene una línea por usuario, con siete campos: nombre, x, UID, GID, comentario, directorio personal y shell.
• Las contraseñas están en /etc/shadow, legible solo por root, y guardadas como un hash.
• /etc/group tiene una línea por grupo. Su lista de miembros no incluye a quienes lo tienen como grupo primario.
• getent consulta usuarios y grupos por nombre o por número, sea cual sea el lugar donde estén definidos.
• who, w y last muestran las sesiones abiertas y las pasadas.
• Cada archivo y cada proceso llevan un UID y un GID. El kernel decide los accesos comparándolos.
• Un cambio en los grupos de un usuario se aplica en su próxima sesión.

16. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Ejecuta id, id -u, id -gn y groups. ¿Cuál es tu UID, tu grupo primario y tus grupos secundarios?
2. Consulta con getent passwd tu propia línea y la de root, e identifica los siete campos de cada una.
3. Cuenta las líneas de /etc/passwd. Luego mira el archivo con less y estima cuántas cuentas admiten sesión, por su último campo.
4. Averigua qué usuario tiene el UID 1, cuál el 33 y cuál el 65534, con getent passwd.
5. Compara ls -l y ls -n en ~/practica, en /etc y en /var/log. ¿Qué grupos distintos de root aparecen en /var/log?
6. Consulta con getent group los grupos sudo, adm y el tuyo. ¿Quiénes son miembros de cada uno?
7. Intenta leer /etc/shadow. Mira sus permisos con ls -l y explica el mensaje a partir de la salida de id.
8. Ejecuta who, w y last -n 10. ¿Desde cuándo está encendido el equipo?
9. Con find /var -maxdepth 2 -user www-data 2>/dev/null y cambiando el nombre por syslog, busca qué archivos pertenecen a usuarios de sistema.
10. Lee man 5 passwd y man 5 group. ¿Por qué hay que escribir el 5?