# Cómo comprobar los usuarios de un sistema Linux

- Link: https://binariocero.com/linux/como-comprobar-los-usuarios-de-un-sistema-linux
- Published: 2026-10-03T19:10:50+02:00
- Author: Juan José Fernández Durán

![Loading](https://binariocero.com/wp-content/plugins/page-views-count/ajax-loader-
2x.gif)

En la administración de sistemas Linux es importante conocer qué usuarios existen
en un servidor, qué permisos tienen y cuáles de ellos pueden iniciar sesión. Una
revisión periódica de las cuentas permite detectar usuarios que ya no deberían existir,
cuentas de servicio mal configuradas o accesos que no estaban previstos.

Linux almacena la información básica de las cuentas locales principalmente en `/
etc/passwd`, mientras que la información relacionada con las contraseñas se encuentra
en `/etc/shadow`.

A continuación veremos los principales comandos para comprobar los usuarios de un
sistema Linux.

## 1. Listar todos los usuarios

La forma más sencilla de consultar las cuentas existentes es utilizar:

    ```wp-block-code
    cat /etc/passwd
    ```

Cada línea corresponde a un usuario y está formada por varios campos separados por`:`.

Por ejemplo:

    ```wp-block-code
    root:x:0:0:root:/root:/bin/bash
    user:x:1001:1001:Usuario:/home/user:/bin/bash
    ```

Los campos son:

 1. Nombre de usuario.
 2. Contraseña, actualmente representada normalmente por `x`.
 3. UID (User ID).
 4. GID (Group ID).
 5. Descripción o información del usuario.
 6. Directorio personal.
 7. Shell de inicio de sesión.

También podemos utilizar:

    ```wp-block-code
    cut -d: -f1 /etc/passwd
    ```

para mostrar únicamente los nombres de usuario.

## 2. Consultar un usuario concreto

Para comprobar si existe una determinada cuenta podemos utilizar:

    ```wp-block-code
    id usuario
    ```

Por ejemplo:

    ```wp-block-code
    id user
    ```

La salida puede mostrar información como:

    ```wp-block-code
    uid=1001(user) gid=1001(user) groups=1001(user),27(sudo)
    ```

Esto permite conocer rápidamente el UID, el grupo principal y los grupos adicionales
del usuario.

Otra opción es:

    ```wp-block-code
    getent passwd user
    ```

`getent` es especialmente útil en sistemas que utilizan fuentes externas de autenticación,
como LDAP, además de las cuentas locales.

## 3. Diferenciar usuarios normales y cuentas del sistema

No todas las cuentas que aparecen en `/etc/passwd` corresponden a personas.

Linux utiliza numerosas cuentas para ejecutar servicios y procesos, por ejemplo:

    ```wp-block-code
    www-data
    mysql
    postgres
    nginx
    sshd
    systemd-network
    ```

Una forma habitual de identificar usuarios humanos es buscar cuentas con UID a partir
del rango utilizado para usuarios normales.

Por ejemplo:

    ```wp-block-code
    awk -F: '$3 >= 1000 {print $1, $3, $6, $7}' /etc/passwd
    ```

Esto muestra:

 * usuario
 * UID
 * directorio personal
 * shell

Sin embargo, el valor de `1000` no debe considerarse una regla universal. El rango
de UID utilizado para usuarios normales depende de la distribución y de su configuración.

Por eso, para una auditoría completa es recomendable comprobar también la configuración
de `/etc/login.defs`.

    ```wp-block-code
    grep -E '^(UID_MIN|UID_MAX)' /etc/login.defs
    ```

## 4. Comprobar qué usuarios pueden iniciar sesión

Una cuenta puede existir en el sistema sin tener permitido iniciar una sesión interactiva.

Para detectar las cuentas que utilizan shells habituales:

    ```wp-block-code
    grep -E '/(bash|sh|zsh|fish)$' /etc/passwd
    ```

También es importante identificar las cuentas cuyo shell es:

    ```wp-block-code
    /usr/sbin/nologin
    ```

o:

    ```wp-block-code
    /bin/false
    ```

Estas configuraciones suelen utilizarse para impedir el acceso interactivo a cuentas
de servicio.

Podemos localizar estas cuentas con:

    ```wp-block-code
    grep -E '/(nologin|false)$' /etc/passwd
    ```

No obstante, no debemos asumir automáticamente que una cuenta con `/bin/bash` representa
a una persona. Una cuenta de servicio también puede estar configurada con un shell
válido.

## 5. Comprobar si una cuenta está bloqueada

Podemos consultar el estado de una cuenta mediante:

    ```wp-block-code
    passwd -S usuario
    ```

Por ejemplo:

    ```wp-block-code
    passwd -S user
    ```

La salida permite determinar si la contraseña de la cuenta está activa o bloqueada.

Otra herramienta especialmente útil es:

    ```wp-block-code
    chage -l usuario
    ```

Por ejemplo:

    ```wp-block-code
    sudo chage -l user
    ```

Este comando muestra información relacionada con la contraseña, como:

 * última modificación de la contraseña;
 * fecha de expiración;
 * periodo máximo de validez;
 * periodo mínimo;
 * periodo de aviso;
 * fechas relacionadas con la expiración de la cuenta.

## 6. Revisar las cuentas con privilegios administrativos

Una de las comprobaciones más importantes consiste en identificar qué usuarios tienen
capacidad para ejecutar comandos con privilegios elevados.

Podemos consultar los miembros del grupo `sudo`:

    ```wp-block-code
    getent group sudo
    ```

En algunas distribuciones, el grupo utilizado es `wheel`:

    ```wp-block-code
    getent group wheel
    ```

También podemos comprobar directamente los grupos de un usuario:

    ```wp-block-code
    groups usuario
    ```

o:

    ```wp-block-code
    id usuario
    ```

Además, hay que revisar la configuración de `sudo`, especialmente:

    ```wp-block-code
    /etc/sudoers
    ```

y:

    ```wp-block-code
    /etc/sudoers.d/
    ```

Para comprobar la configuración efectiva de sudo es recomendable utilizar:

    ```wp-block-code
    sudo -l -U usuario
    ```

Esto permite conocer qué comandos puede ejecutar un usuario mediante `sudo`.

## 7. Buscar usuarios con UID 0

El UID `0` corresponde a `root`.

Por seguridad, conviene comprobar qué cuentas tienen este UID:

    ```wp-block-code
    awk -F: '$3 == 0 {print $1}' /etc/passwd
    ```

En una configuración convencional debería aparecer:

    ```wp-block-code
    root
    ```

Si aparecen otras cuentas con UID 0, deben investigarse cuidadosamente, ya que disponen
esencialmente de los mismos privilegios que `root`.

## 8. Comprobar usuarios conectados actualmente

Para saber qué usuarios tienen sesiones abiertas podemos utilizar:

    ```wp-block-code
    who
    ```

Otra opción es:

    ```wp-block-code
    w
    ```

`w` proporciona información adicional, incluyendo desde dónde está conectado el 
usuario y qué proceso está ejecutando.

También podemos utilizar:

    ```wp-block-code
    users
    ```

que muestra de forma resumida los usuarios que tienen una sesión abierta.

Para obtener información sobre sesiones gestionadas por systemd:

    ```wp-block-code
    loginctl list-sessions
    ```

Y para consultar los detalles de una sesión concreta:

    ```wp-block-code
    loginctl session-status ID
    ```

## 9. Revisar los últimos accesos

Linux mantiene información sobre los accesos realizados al sistema.

El comando:

    ```wp-block-code
    last
    ```

permite consultar los últimos inicios de sesión registrados.

Por ejemplo:

    ```wp-block-code
    last -20
    ```

muestra las últimas 20 entradas.

También podemos comprobar los últimos accesos de un usuario concreto:

    ```wp-block-code
    last usuario
    ```

Para consultar intentos de autenticación fallidos, dependiendo de la distribución
y configuración de logging, pueden utilizarse:

    ```wp-block-code
    lastb
    ```

o revisar los registros de autenticación.

En sistemas basados en Debian/Ubuntu suele ser especialmente relevante:

    ```wp-block-code
    /var/log/auth.log
    ```

Mientras que en sistemas como RHEL, Rocky Linux o AlmaLinux puede encontrarse información
equivalente en:

    ```wp-block-code
    /var/log/secure
    ```

## 10. Buscar cuentas sin contraseña

Una comprobación importante durante una auditoría consiste en detectar cuentas que
puedan tener una contraseña vacía.

Una primera revisión puede hacerse sobre `/etc/shadow`:

    ```wp-block-code
    sudo awk -F: '$2 == "" {print $1}' /etc/shadow
    ```

Si el comando devuelve algún usuario, conviene investigar inmediatamente esa cuenta.

Hay que tener en cuenta que `/etc/shadow` contiene información sensible y debe protegerse
adecuadamente. Normalmente sólo `root` y procesos con los permisos correspondientes
pueden acceder a su contenido.

## 11. Revisar los directorios personales

Los usuarios normales suelen tener un directorio personal bajo `/home`.

Podemos comprobarlos mediante:

    ```wp-block-code
    ls -la /home
    ```

También podemos buscar los directorios personales definidos en `/etc/passwd`:

    ```wp-block-code
    awk -F: '$6 ~ /^\/home\// {print $1, $6}' /etc/passwd
    ```

Esto resulta útil para detectar cuentas que aparentemente son usuarios normales 
pero que no tienen un directorio personal coherente con la configuración del sistema.

## 12. Comprobar grupos de un usuario

Los grupos determinan buena parte de los permisos que puede tener una cuenta.

Para consultar los grupos de un usuario:

    ```wp-block-code
    id usuario
    ```

o:

    ```wp-block-code
    groups usuario
    ```

Por ejemplo:

    ```wp-block-code
    id user
    ```

Es especialmente importante prestar atención a grupos con privilegios elevados, 
como:

    ```wp-block-code
    sudo
    wheel
    adm
    docker
    libvirt
    ```

El significado exacto de cada grupo depende de la distribución y de los servicios
instalados.

Por ejemplo, pertenecer al grupo `docker` puede proporcionar capacidades muy elevadas
sobre el sistema, por lo que no debe considerarse un grupo administrativo "menor".

## 13. Comprobar usuarios del sistema con un pequeño informe

Para realizar una revisión rápida podemos utilizar:

    ```wp-block-code
    awk -F: '{printf "%-20s UID=%-6s HOME=%-25s SHELL=%s\n",$1,$3,$6,$7}' /etc/passwd
    ```

Esto genera una salida similar a:

    ```wp-block-code
    root                 UID=0      HOME=/root                    SHELL=/bin/bash
    www-data             UID=33     HOME=/var/www                 SHELL=/usr/sbin/nologin
    user                 UID=1001   HOME=/home/user               SHELL=/bin/bash
    ```

De esta forma resulta mucho más sencillo revisar visualmente las cuentas existentes.

## 14. Qué deberíamos buscar durante una auditoría

Cuando revisamos los usuarios de un servidor Linux, no basta con comprobar cuántas
cuentas existen. Es recomendable buscar especialmente:

 * usuarios que ya no deberían existir;
 * cuentas desconocidas;
 * usuarios con UID 0 distintos de `root`;
 * cuentas con privilegios `sudo` o `wheel` que no deberían tenerlos;
 * usuarios con shells interactivos innecesarios;
 * cuentas de servicio con configuraciones incorrectas;
 * contraseñas o cuentas sin una política de expiración adecuada;
 * accesos recientes de usuarios que ya no deberían utilizar el servidor;
 * sesiones activas inesperadas;
 * pertenencia a grupos con privilegios elevados;
 * cuentas creadas recientemente sin una justificación conocida.

## 15. Comandos básicos para una revisión rápida

Una revisión inicial puede realizarse con los siguientes comandos:

    ```wp-block-code
    # Listar usuarios
    cut -d: -f1 /etc/passwd

    # Información de un usuario
    id usuario

    # Información de contraseña
    sudo chage -l usuario

    # Usuarios con UID 0
    awk -F: '$3 == 0 {print $1}' /etc/passwd

    # Usuarios con shells interactivos
    grep -E '/(bash|sh|zsh|fish)$' /etc/passwd

    # Usuarios actualmente conectados
    who

    # Últimos accesos
    last -20

    # Sesiones actuales
    loginctl list-sessions

    # Grupos administrativos
    getent group sudo
    getent group wheel
    ```

## Conclusión

Comprobar los usuarios de Linux es una tarea fundamental dentro de la administración
y auditoría de cualquier servidor. La revisión no debería limitarse a ejecutar `
cat /etc/passwd`, sino que debería incluir también los UID, grupos, privilegios,
shells, estado de las cuentas y registros de acceso.

Una revisión periódica permite identificar cuentas innecesarias, privilegios excesivos
y posibles accesos no autorizados antes de que se conviertan en un problema de seguridad.

Para una auditoría completa, además de las cuentas locales, conviene comprobar si
el servidor utiliza mecanismos externos de autenticación como LDAP, Active Directory,
Kerberos u otros proveedores de identidad, ya que en esos casos `getent passwd` 
e `id` pueden proporcionar una visión más completa que consultar únicamente `/etc/
passwd`.
