Domina los permisos en Linux: chmod, chown y chgrp paso a paso

Introducción

En el mundo de los servidores y las máquinas Linux, la gestión de permisos y propietarios de archivos es una habilidad que todo operador, desarrollador o administrador debe dominar. Sin un control fino sobre quién puede leer, escribir o ejecutar cada fichero, tu sistema es vulnerable a errores humanos y a ataques de seguridad.

Este artículo está pensado para personas que ya manejan la terminal pero que quieren profundizar en los comandos chmod, chown y chgrp. Aprenderás a usar los dos modos de chmod (octal y simbólico), a cambiar propietarios y grupos, y a validar los cambios con ls -l. Además, te dejo ejemplos reales y la salida que deberías ver antes y después de cada operación.

Al final del post tendrás:

1. Una comprensión clara de la estructura de permisos en Linux.
2. La capacidad de cambiar permisos tanto de forma numérica como simbólica.
3. Dominar el uso de chown y chgrp para editar propietarios y grupos.
4. Buenas prácticas para evitar errores comunes y mantener tu sistema seguro.

Empecemos.

¿Cómo funciona la gestión de permisos en Linux?

En Linux, cada fichero y directorio tiene tres conjuntos de permisos: usuario dueño (owner), grupo y otros. Cada conjunto se compone de tres bits: lectura (r), escritura (w) y ejecución (x). La combinación de estos bits determina si un proceso con ciertos privilegios puede interactuar con el recurso.

-rwxr-xr-- 1 alice developers  4096 Jun 20 10:15 script.sh

• El primer carácter indica el tipo de fichero (- para regular, d para directorio, l para enlace simbólico, etc.).
• Los siguientes nueve caracteres se agrupan en tres bloques de tres: owner (rwx), group (r-x) y others (r--).
• El número 1 indica el número de enlaces duros.
• alice es el propietario y developers el grupo.
• El tamaño, la fecha y el nombre siguen después.

Los bits de permiso en formato octal

Cada bloque de tres bits puede representarse como un número octal (0‑7). Se suman los valores de cada permiso:

Por ejemplo, rwx es 4+2+1 = 7, r-x es 4+0+1 = 5, y r-- es 4+0+0 = 4.

chmod en modo octal

El modo octal es el más directo y se escribe con chmod seguido de un número de tres dígitos (o cuatro si se incluyen bits especiales). Cada dígito corresponde a uno de los tres grupos de permisos.

Cambiar permisos de un fichero

Supongamos que tenemos un script llamado deploy.sh que solo debe ser ejecutable por el propietario y legible por el grupo y otros usuarios.

$ ls -l deploy.sh
-rw-r--r-- 1 alice developers  1024 Jun 20 10:45 deploy.sh

Para hacer que solo el propietario tenga permiso de escritura y ejecución, y que el resto tenga solo lectura, usaremos chmod 754.

$ chmod 754 deploy.sh
$ ls -l deploy.sh
-rwxr-xr-- 1 alice developers  1024 Jun 20 10:45 deploy.sh

Explicación:

• 7 (owner) = rwx.
• 5 (group) = r-x.
• 4 (others) = r--.

Cambiar permisos de un directorio recursivamente

Para cambiar permisos de un directorio y todos sus subdirectorios y ficheros, se usa la opción -R.

$ chmod -R 755 /var/www/html

Esto hará que todo el contenido tenga permisos rwxr-xr-x, permitiendo que el propietario lea, escriba y ejecute, mientras que el grupo y otros solo lean y ejecuten.

chmod en modo simbólico

El modo simbólico es más expresivo y permite modificar permisos sin reescribir el valor completo. Se emplea la sintaxis: chmod [usuario][operación][permisos] archivo.

Operadores

Usuarios

Ejemplos prácticos

1. Dar permiso de escritura al grupo sin afectar a los demás:

$ chmod g+w document.txt
$ ls -l document.txt
-rw-rw-r-- 1 alice developers  2048 Jun 20 11:00 document.txt

1. Quitar permiso de ejecución de otros en un directorio:

$ chmod o-x /opt/software
$ ls -ld /opt/software
drwxr-xr-x 2 alice developers 4096 Jun 20 11:05 /opt/software

1. Establecer permisos 644 usando simbólico (igual a chmod 644):

$ chmod u=rw,go=r file.txt
$ ls -l file.txt
-rw-r--r-- 1 alice developers  4096 Jun 20 11:15 file.txt

1. Añadir permiso de ejecución a todos en un script que acabás de crear:

$ touch new_script.sh
$ chmod +x new_script.sh
$ ls -l new_script.sh
-rwx------ 1 alice developers 0 Jun 20 11:20 new_script.sh

Maneras de combinar

Para añadir lectura al propietario y escritura al grupo sin tocar otros permisos:

$ chmod u+r,g+w file.txt

O, si quieres quitar lectura a todos excepto al propietario y al grupo:

$ chmod a-r,u+r,g+r file.txt

Cambiar propietarios con chown

chown cambia el propietario y opcionalmente el grupo de un fichero o directorio. La sintaxis general es:

chown [opciones] usuario[:grupo] archivo

Cambiar solo el propietario

Supongamos que un documento creado por bob debe transferirse a alice.

$ ls -l secret.txt
-rw-rw-r-- 1 bob developers  512 Jun 20 12:00 secret.txt
$ chown alice secret.txt
$ ls -l secret.txt
-rw-rw-r-- 1 alice developers  512 Jun 20 12:00 secret.txt

Cambiar propietario y grupo

Si además quieres que el grupo cambie a admins:

$ chown alice:admins secret.txt
$ ls -l secret.txt
-rw-rw-r-- 1 alice admins  512 Jun 20 12:00 secret.txt

Recursivamente

Para cambiar propietario y grupo en un directorio y su contenido:

$ chown -R alice:admins /home/alice/projects

Cambiar solo el grupo con chgrp

chgrp es equivalente a chown pero solo modifica el grupo.

$ ls -l script.py
-rw-rw-r-- 1 alice developers  1024 Jun 20 13:00 script.py
$ chgrp admins script.py
$ ls -l script.py
-rw-rw-r-- 1 alice admins  1024 Jun 20 13:00 script.py

Recursivo

$ chgrp -R admins /var/www/html

Visualizar permisos antes y después

Para que comprendas el efecto real de tus cambios, siempre es útil ver la salida de ls -l antes y después.

Ejemplo completo

Supongamos que tienes el siguiente árbol:

/home/alice
├── app.py
├── config
│   └── settings.yml
└── logs
    ├── app.log
    └── error.log

Antes

$ ls -l /home/alice
-rw-rw-r-- 1 alice developers  1024 Jun 20 14:00 app.py
$ ls -l /home/alice/config
-rw-rw-r-- 1 alice developers  512 Jun 20 14:00 settings.yml
$ ls -l /home/alice/logs
-rw-rw-r-- 1 alice developers  1048576 Jun 20 14:00 app.log
-rw-rw-r-- 1 alice developers  2048 Jun 20 14:00 error.log

Cambiar permisos con chmod

$ chmod -R 750 /home/alice

Después

$ ls -l /home/alice
-rwxr-x--- 1 alice developers  1024 Jun 20 14:00 app.py
$ ls -l /home/alice/config
-rwxr-x--- 1 alice developers  512 Jun 20 14:00 settings.yml
$ ls -l /home/alice/logs
-rwxr-x--- 1 alice developers 1048576 Jun 20 14:00 app.log
-rwxr-x--- 1 alice developers   2048 Jun 20 14:00 error.log

Cambiar propietario y grupo con chown

Supongamos que los ficheros deben pasar a bob y el grupo a admins.

$ chown -R bob:admins /home/alice

Verificación

$ ls -l /home/alice
-rwxr-x--- 1 bob admins  1024 Jun 20 14:00 app.py
$ ls -l /home/alice/config
-rwxr-x--- 1 bob admins  512 Jun 20 14:00 settings.yml
$ ls -l /home/alice/logs
-rwxr-x--- 1 bob admins 1048576 Jun 20 14:00 app.log
-rwxr-x--- 1 bob admins   2048 Jun 20 14:00 error.log

Buenas prácticas y errores comunes

Recomendaciones finales

1. Define roles claros: Asigna grupos específicos para cada equipo o función.
2. Usa permisos mínimos necesarios: Aplica el principio de privilegio mínimo.
3. Automatiza con scripts: Guarda los comandos en scripts idempotentes para aplicar configuraciones.
4. Documenta tus cambios: Lleva un registro de quién cambió qué y cuándo.
5. Prueba en entorno de staging: Antes de aplicar a producción, verifica en un entorno similar.

Conclusión

Dominar chmod, chown y chgrp es esencial para mantener la seguridad y el orden en cualquier sistema Linux. Con los ejemplos anteriores y siguiendo las buenas prácticas, vos podés controlarle a cada fichero y directorio cuántos permisos tiene y quiénes pueden acceder a él. Recordá siempre validar los cambios con ls -l y no subestimar la importancia de los grupos. ¡Éxitos aplicando estos comandos en tus proyectos!