Permisos en Linux — teoría con chmod en octal y en letras, umask y la carpeta de un trabajo en grupo (y el script que no quería arrancar)

Once de la noche, víspera de entregar la práctica de IC2. Laura, mi compañera de grupo, me pasa por el chat el script que compila todo. Lo guardo, lo lanzo y…

# La noche antes de la entrega: el script del grupo no arranca
cat > compilar.sh << 'EOF'
#!/bin/bash
echo "Compilando la práctica de IC2..."
EOF
./compilar.sh            # lo intento ejecutar... y Linux dice que no
ls -l compilar.sh        # la respuesta está en los diez primeros caracteres
chmod u+x compilar.sh    # u = el dueño (yo), + = añadir, x = ejecutar
ls -l compilar.sh        # ahora hay una x en el primer trío
./compilar.sh

Esto es lo que contestó la terminal:

$ cat > compilar.sh << 'EOF'
> #!/bin/bash
> echo "Compilando la práctica de IC2..."
> EOF
$ ./compilar.sh
bash: ./compilar.sh: Permission denied
$ ls -l compilar.sh
-rw-r--r-- 1 sergio sergio 53 Oct 25 16:49 compilar.sh
$ chmod u+x compilar.sh
$ ls -l compilar.sh
-rwxr--r-- 1 sergio sergio 53 Oct 25 16:49 compilar.sh
$ ./compilar.sh
Compilando la práctica de IC2...

Permission denied. Lo primero que pensé fue que el script estaba roto. Lo segundo, que Laura me había pasado otra versión. Estuve veinte minutos revisando un archivo de dos líneas que estaba perfecto, y casi acabo escribiendo chmod 777 «para que funcione ya». El problema estaba a la vista desde el principio: en -rw-r--r-- no hay ninguna x. El fichero se podía leer y escribir, pero nadie (ni yo, que era su dueño) tenía permiso para ejecutarlo. Un chmod u+x y listo: el mismo ls -l ya enseña -rwxr--r-- y el script arranca.

Hoy vamos a entender esos diez caracteres de verdad: quién es «el dueño», «el grupo» y «los otros», qué significan r, w y x (que en una carpeta no son lo mismo que en un fichero), cómo se cambian con chmod en octal (754) y en letras (u+x), por qué todo lo que creas nace con 644 o 755 (la umask), quién puede cambiar el dueño de un fichero y qué son esas s y t raras que a veces aparecen. Si vienes del artículo de llamadas al sistema en C, ya te sonará el 0644 que le pasábamos a open: hoy verás qué significa cada cifra. Y si la terminal aún te impone, repasa antes los comandos básicos de Linux. Después de la teoría tienes la práctica y los ejercicios.

El ejemplo que nos acompaña en los tres artículos es la carpeta de un trabajo en grupo de IC2: yo (sergio) soy el dueño, Laura y yo estamos en el grupo ic2, y Pablo, de otra clase, es «el resto del mundo».

Quién es quién: dueño, grupo y otros

Linux es un sistema multiusuario: en el mismo ordenador conviven varias cuentas y cada fichero tiene que saber quién puede hacer qué con él. Para no guardar una lista de permisos por persona, Linux simplifica y divide el mundo en tres clases:

• Dueño (u, de user): el usuario al que pertenece el fichero. Normalmente, quien lo creó.
• Grupo (g): un grupo de usuarios asociado al fichero. Todos sus miembros comparten unos mismos permisos.
• Otros (o, de others): cualquier usuario que no sea el dueño ni esté en el grupo.

¿Y cómo sabes quién eres tú y en qué grupos estás? Con id:

id

En el ordenador de la práctica sale esto:

uid=1001(sergio) gid=1001(sergio) groups=1001(sergio),1010(ic2)

Se lee así: mi usuario es sergio (con el número 1001), mi grupo principal también se llama sergio y, además, pertenezco al grupo ic2, el del trabajo. Los números (uid, gid) son lo que Linux guarda de verdad; los nombres son para nosotros.

Una idea que conviene tener clara desde ya: cuando intentas abrir un fichero, Linux no suma los permisos de las tres clases. Mira una sola: si eres el dueño, usa el trío del dueño; si no lo eres pero estás en el grupo, el del grupo; y si no, el de otros. Lo comprobarás en la práctica con un resultado bastante sorprendente.

Leer los permisos con ls -l

Vamos a crear tres cosas distintas (un directorio, un fichero vacío y el script) y a mirarlas con ls -l:

# ¿Quién soy? Usuario, grupo principal y todos los grupos a los que pertenezco
id
mkdir docs                # un directorio
touch informe.txt         # un fichero vacío
cat > compilar.sh << 'EOF'
#!/bin/bash
echo "Compilando la práctica de IC2..."
EOF
ls -l                     # una línea por entrada: permisos, enlaces, dueño, grupo, tamaño, fecha, nombre

La salida real:

$ id
uid=1001(sergio) gid=1001(sergio) groups=1001(sergio),1010(ic2)
$ mkdir docs
$ touch informe.txt
$ cat > compilar.sh << 'EOF'
> #!/bin/bash
> echo "Compilando la práctica de IC2..."
> EOF
$ ls -l
total 8
-rw-r--r-- 1 sergio sergio   53 Oct 25 16:49 compilar.sh
drwxr-xr-x 2 sergio sergio 4096 Oct 25 16:49 docs
-rw-r--r-- 1 sergio sergio    0 Oct 25 16:49 informe.txt

Cada línea tiene siete columnas. El dibujo separa la del script pieza a pieza:

Vamos por partes, fijándonos en el dibujo:

1. El primer carácter es el tipo: - para un fichero normal, d para un directorio (docs) y l para un enlace simbólico.
2. Los nueve siguientes son tres tríos de rwx: el del dueño, el del grupo y el de otros, en ese orden y siempre en ese orden. Cada posición tiene su letra fija (primero r, luego w, luego x); un - significa «este permiso no».
3. El número que viene después es el de enlaces (para un directorio, cuenta también sus subdirectorios; hoy no nos importa).
4. Dueño y grupo: sergio sergio.
5. El tamaño en bytes: el script ocupa 53 bytes; docs ocupa 4096 porque un directorio reserva un bloque para su lista de nombres.
6. La fecha de la última modificación y el nombre.

¿Qué significa cada letra en un fichero?

Letra	En un fichero	Ejemplo
r (read)	leer su contenido	cat, less, abrirlo con open(…, O_RDONLY)
w (write)	modificar su contenido	echo … >> fichero, guardarlo en un editor
x (execute)	ejecutarlo como programa	./compilar.sh, ./a.out

Ahora ya puedes leer la salida de arriba: compilar.sh e informe.txt tienen rw-r--r-- (yo leo y escribo; el grupo y los otros solo leen) y docs tiene rwxr-xr-x. ¿Por qué el directorio nace con x y los ficheros no? No es casualidad: lo decide la umask, que verás más abajo.

Cambiar permisos con chmod en octal

chmod (change mode) cambia los permisos. La forma más rápida de usarlo es con tres cifras octales, una por trío. El truco es que cada letra tiene un peso:

• r vale 4
• w vale 2
• x vale 1

Sumas los pesos de las letras que quieres y te sale una cifra entre 0 y 7. Como 4, 2 y 1 son potencias de dos, cada suma es única: 6 solo puede ser 4 + 2 (rw-) y 5 solo puede ser 4 + 1 (r-x). Por eso no hay ambigüedad.

touch compilar.sh entrega.txt notas.txt
chmod 754 compilar.sh     # 7 = 4+2+1 = rwx (yo) · 5 = 4+1 = r-x (grupo) · 4 = r-- (otros)
chmod 640 entrega.txt     # 6 = 4+2 = rw- · 4 = r-- · 0 = --- (otros no ven nada)
chmod 600 notas.txt       # solo yo leo y escribo
# %a = permisos en octal, %A = en letras, %n = nombre: las dos notaciones una al lado de la otra
stat -c '%a %A %n' compilar.sh entrega.txt notas.txt

Con stat -c '%a %A %n' vemos a la vez el número, las letras y el nombre:

$ touch compilar.sh entrega.txt notas.txt
$ chmod 754 compilar.sh
$ chmod 640 entrega.txt
$ chmod 600 notas.txt
$ stat -c '%a %A %n' compilar.sh entrega.txt notas.txt
754 -rwxr-xr-- compilar.sh
640 -rw-r----- entrega.txt
600 -rw------- notas.txt

El dibujo descompone el primero, 754, cifra a cifra:

Comprobación a mano de los tres:

• 754: 7 = 4 + 2 + 1 = rwx; 5 = 4 + 0 + 1 = r-x; 4 = 4 + 0 + 0 = r-- → rwxr-xr--.
• 640: 6 = 4 + 2 = rw-; 4 = r--; 0 = --- → rw-r-----.
• 600: 6 = rw-; 0 = ---; 0 = --- → rw-------.

Hay media docena de valores que vas a usar el 90 % de las veces:

Octal	Letras	¿Para qué?
755	rwxr-xr-x	scripts y programas que todos pueden usar; directorios normales
750	rwxr-x---	scripts o carpetas de un grupo de trabajo
700	rwx------	tu carpeta privada, tus scripts personales
644	rw-r--r--	ficheros normales que cualquiera puede leer
640	rw-r-----	documentos del grupo: el grupo lee, el resto no
600	rw-------	ficheros privados: claves, notas, configuraciones con contraseñas

Cambiar permisos en modo simbólico

La forma octal fija los nueve bits de golpe. A veces solo quieres tocar uno sin preocuparte del resto, y para eso está el modo simbólico, que se construye con tres piezas:

1. ¿A quién? u (dueño), g (grupo), o (otros) o a (all, los tres). Se pueden juntar: ug, go…
2. ¿Qué operación? + añade, - quita y = fija exactamente (lo que no nombres, se borra).
3. ¿Qué permisos? r, w, x o una combinación.

Varias órdenes se separan con comas sin espacios: chmod u+x,g-w fichero.

touch entrega.txt
stat -c '%a %A %n' entrega.txt     # punto de partida
chmod g+w entrega.txt              # + añade: el grupo ya puede escribir
stat -c '%a %A %n' entrega.txt
chmod o-r entrega.txt              # - quita: otros ya no pueden leer
stat -c '%a %A %n' entrega.txt
chmod u=rw,g=r,o= entrega.txt      # = fija exactamente; 'o=' sin letras deja a otros sin nada
stat -c '%a %A %n' entrega.txt
chmod a+x entrega.txt              # a = all: u, g y o a la vez
stat -c '%a %A %n' entrega.txt

La salida real, paso a paso:

$ touch entrega.txt
$ stat -c '%a %A %n' entrega.txt
644 -rw-r--r-- entrega.txt
$ chmod g+w entrega.txt
$ stat -c '%a %A %n' entrega.txt
664 -rw-rw-r-- entrega.txt
$ chmod o-r entrega.txt
$ stat -c '%a %A %n' entrega.txt
660 -rw-rw---- entrega.txt
$ chmod u=rw,g=r,o= entrega.txt
$ stat -c '%a %A %n' entrega.txt
640 -rw-r----- entrega.txt
$ chmod a+x entrega.txt
$ stat -c '%a %A %n' entrega.txt
751 -rwxr-x--x entrega.txt

Esta es la traza de lo que hizo cada orden sobre entrega.txt:

Orden	Antes	Después	¿Qué ha pasado?
(recién creado)	—	644 rw-r--r--	lo decide la umask
chmod g+w	644	664 rw-rw-r--	el grupo gana la w: 4 + 2 = 6
chmod o-r	664	660 rw-rw----	otros pierden la r: 4 − 4 = 0
chmod u=rw,g=r,o=	660	640 rw-r-----	= fija cada trío; o= sin letras lo deja vacío
chmod a+x	640	751 rwxr-x--x	una x más en cada trío: 6 + 1 = 7, 4 + 1 = 5, 0 + 1 = 1

Fíjate en la última fila: a+x solo añade, así que respeta lo que ya había. El grupo tenía r-- y se queda en r-x; otros no tenían nada y se quedan solo con x. Con el octal habrías tenido que calcular el número completo a mano.

¿Cuándo uso cada forma?

Quiero…	Mejor	Ejemplo
dejar un fichero con unos permisos exactos	octal	chmod 640 entrega.txt
añadir o quitar un permiso sin tocar los demás	simbólico	chmod u+x compilar.sh
cambiar muchos ficheros que tienen permisos distintos	simbólico	chmod -R o-rwx carpeta
copiar los permisos que me dicen en un enunciado («ponlo a 750»)	octal	chmod 750 carpeta

Los permisos en los directorios

Aquí es donde se equivoca casi todo el mundo, porque las mismas tres letras significan otra cosa en un directorio. Un directorio no es más que una lista de nombres que apuntan a ficheros, así que:

Letra	En un fichero	En un directorio
r	leer el contenido	leer la lista de nombres (ls)
w	modificar el contenido	crear, borrar y renombrar entradas dentro (con x también)
x	ejecutarlo	entrar (cd) y acceder a lo que hay dentro por su nombre

Vamos a jugar con una carpeta privado y a quitarle y ponerle permisos a propósito:

mkdir privado
echo "tema 3: permisos" > privado/apuntes.txt
chmod 600 privado         # rw- en un DIRECTORIO: leer la lista y escribir en ella, pero SIN x
ls privado                # los nombres sí se ven (r)...
ls -l privado             # ...pero no los datos de cada fichero: hace falta x para entrar
cd privado                # y sin x tampoco se puede entrar
chmod 300 privado         # -wx: entrar sí, listar no
ls privado
cat privado/apuntes.txt   # si sabes el nombre exacto, puedes abrirlo
chmod 755 privado         # lo normal en un directorio: rwx para mí, r-x para el resto
ls -l privado

Lo que pasó de verdad:

$ mkdir privado
$ echo "tema 3: permisos" > privado/apuntes.txt
$ chmod 600 privado
$ ls privado
apuntes.txt
$ ls -l privado
ls: cannot access 'privado/apuntes.txt': Permission denied
total 0
-????????? ? ? ? ?            ? apuntes.txt
$ cd privado
bash: cd: privado: Permission denied
$ chmod 300 privado
$ ls privado
ls: cannot open directory 'privado': Permission denied
$ cat privado/apuntes.txt
tema 3: permisos
$ chmod 755 privado
$ ls -l privado
total 4
-rw-r--r-- 1 sergio sergio 17 Oct 25 16:49 apuntes.txt

Leámoslo por partes:

• Con 600 (rw-, sin x), ls privado sí enseña el nombre apuntes.txt: para leer la lista basta con la r. Pero ls -l necesita además consultar los datos de cada fichero (permisos, tamaño, fecha), y para eso hay que entrar en el directorio, que es justo lo que da la x. Por eso sale -????????? con interrogaciones en todas las columnas. Y cd privado falla por lo mismo.
• Con 300 (-wx, sin r) pasa justo lo contrario: no puedes listar (ls: cannot open directory), pero si sabes el nombre exacto del fichero, puedes llegar hasta él y abrirlo (cat privado/apuntes.txt funciona). Es como una habitación con la luz apagada: puedes entrar, pero no ves qué hay; si sabes dónde está el interruptor, lo encuentras.
• Con 755 todo vuelve a la normalidad.

umask: los permisos con los que nace todo

¿Por qué touch crea los ficheros con 644 y mkdir los directorios con 755? Porque los programas piden unos permisos «máximos» y el sistema les aplica una máscara, la umask, que apaga algunos bits:

• touch, un editor o open(…, O_CREAT, 0666) piden 666 (rw-rw-rw-) para un fichero. Nunca piden x: un fichero de texto recién creado no tiene por qué ser ejecutable.
• mkdir pide 777 (rwxrwxrwx) para un directorio, porque un directorio sin x no sirve para nada.

umask                     # la máscara actual, en octal
umask -S                  # la misma máscara, como permisos que SÍ se dejan
touch nuevo.txt
mkdir nueva-carpeta
stat -c '%a %A %n' nuevo.txt nueva-carpeta
umask 077                 # a partir de aquí, nada para el grupo ni para otros
touch secreto.txt
mkdir secreta
stat -c '%a %A %n' secreto.txt secreta

La salida real:

$ umask
0022
$ umask -S
u=rwx,g=rx,o=rx
$ touch nuevo.txt
$ mkdir nueva-carpeta
$ stat -c '%a %A %n' nuevo.txt nueva-carpeta
644 -rw-r--r-- nuevo.txt
755 drwxr-xr-x nueva-carpeta
$ umask 077
$ touch secreto.txt
$ mkdir secreta
$ stat -c '%a %A %n' secreto.txt secreta
600 -rw------- secreto.txt
700 drwx------ secreta

umask muestra 0022 (el primer 0 es el de los bits especiales, que verás al final) y umask -S lo enseña al revés: como los permisos que sí deja pasar (u=rwx,g=rx,o=rx). El dibujo explica de dónde sale el 644:

Las cuentas, bit a bit:

• Fichero: 666 = rw-rw-rw-. La máscara 022 = ----w--w- apaga la w del grupo y la de otros. Queda rw-r--r-- = 644.
• Directorio: 777 = rwxrwxrwx, menos las mismas dos w = rwxr-xr-x = 755.
• Con umask 077 se apaga todo lo del grupo y de otros: el fichero queda rw------- (600) y el directorio rwx------ (700).

¿Te acuerdas del 0644 del artículo de llamadas al sistema? Ese tercer argumento de open también pasa por la umask: el fichero se crea con 0644 & ~umask. Con la umask 022 de siempre se queda en 0644; con 077 saldría 0600. Y la umask que ves aquí solo afecta a la terminal donde la cambias: si quieres que sea permanente, la orden umask 027 va en tu ~/.bashrc.

Dueño y grupo: chown y chgrp

Los permisos dicen qué puede hacer cada clase, pero ¿quién es el dueño y cuál es el grupo? Eso se cambia con dos órdenes:

• chgrp grupo fichero cambia el grupo.
• chown usuario fichero cambia el dueño (y chown usuario:grupo fichero, los dos a la vez).

touch entrega.txt
ls -l entrega.txt          # recién creado: dueño sergio, grupo sergio
chgrp ic2 entrega.txt      # soy del grupo ic2, así que puedo darle el fichero a ese grupo
ls -l entrega.txt
chown laura entrega.txt    # pero regalárselo a otra persona solo lo puede hacer root

La salida real:

$ touch entrega.txt
$ ls -l entrega.txt
-rw-r--r-- 1 sergio sergio 0 Oct 25 16:49 entrega.txt
$ chgrp ic2 entrega.txt
$ ls -l entrega.txt
-rw-r--r-- 1 sergio ic2 0 Oct 25 16:49 entrega.txt
$ chown laura entrega.txt
chown: changing ownership of 'entrega.txt': Operation not permitted

El chgrp funciona porque soy el dueño del fichero y pertenezco al grupo ic2: un usuario normal puede pasar sus ficheros a cualquiera de sus grupos. Pero el chown falla con Operation not permitted. ¿Por qué no puedo regalarle mi fichero a Laura? Porque, si se pudiera, cualquiera podría «colocarle» ficheros a otra persona (por ejemplo, para gastar su cuota de disco o para hacer pasar algo como suyo). Por eso solo root puede cambiar el dueño. Con permisos de administrador sería sudo chown laura entrega.txt; esa orden no la he ejecutado aquí porque el usuario de la práctica no tiene sudo.

Los bits especiales: setuid, setgid y sticky

Hay tres permisos más que no caben en rwx y que se guardan en una cuarta cifra octal, la de delante:

Bit	Valor	Dónde se ve	Qué hace
setuid	4	s en la x del dueño	el programa se ejecuta con los permisos de su dueño, no de quien lo lanza
setgid	2	s en la x del grupo	en una carpeta: lo que se cree dentro hereda el grupo de la carpeta
sticky	1	t en la x de otros	en una carpeta: cada usuario solo puede borrar lo suyo

ls -l /usr/bin/passwd      # setuid: una s donde iría la x del dueño
ls -ld /tmp                # sticky: una t donde iría la x de otros
touch lanzar.sh
chmod 4755 lanzar.sh       # 4 = setuid delante de 755
mkdir comun grupo
chmod 1777 comun           # 1 = sticky: todos escriben, cada uno solo borra lo suyo
chmod 2770 grupo           # 2 = setgid: lo que se cree dentro hereda el grupo de la carpeta
stat -c '%a %A %n' lanzar.sh comun grupo

La salida real:

$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 64152 May 30  2024 /usr/bin/passwd
$ ls -ld /tmp
drwxrwxrwt 10 root root 4096 Oct 25 16:49 /tmp
$ touch lanzar.sh
$ chmod 4755 lanzar.sh
$ mkdir comun grupo
$ chmod 1777 comun
$ chmod 2770 grupo
$ stat -c '%a %A %n' lanzar.sh comun grupo
4755 -rwsr-xr-x lanzar.sh
1777 drwxrwxrwt comun
2770 drwxrws--- grupo

• /usr/bin/passwd tiene rwsr-xr-x. Este es el ejemplo clásico de tus apuntes: para cambiar tu contraseña, passwd tiene que escribir en /etc/shadow, que solo puede tocar root. Gracias al setuid, mientras se ejecuta, el proceso tiene como usuario efectivo (el EUID de la práctica de procesos) al dueño del programa, root, aunque lo hayas lanzado tú.
• /tmp tiene rwxrwxrwt: todo el mundo puede escribir, pero la t impide que borres los ficheros temporales de otra persona.
• En lanzar.sh, comun y grupo ves los tres bits puestos por nosotros: 4755, 1777 y 2770. La cuarta cifra se suma igual que las otras: 4 + 2 = 6 sería setuid y setgid a la vez.

Un detalle de las letras: la s o la t minúscula significa que debajo también está la x; si sale en mayúscula (S o T), el bit especial está puesto pero la x no. Lo verás en el nivel 3 de los ejercicios, con una carpeta drwxrws--T.

Errores típicos

Pruébalo en tu terminal

Aquí no hay Python Tutor: el «paso a paso» lo hace tu propia terminal. Abre una (en Linux, en WSL o en la máquina virtual de prácticas), crea una carpeta para no tocar nada importante (mkdir ~/prueba-permisos && cd ~/prueba-permisos) y teclea las órdenes que van detrás de cada $. Esto es lo que deberías ver:

$ touch prueba.txt
$ stat -c '%a %A %n' prueba.txt
644 -rw-r--r-- prueba.txt
$ chmod 600 prueba.txt
$ stat -c '%a %A %n' prueba.txt
600 -rw------- prueba.txt
$ chmod u+x,g+r prueba.txt
$ stat -c '%a %A %n' prueba.txt
740 -rwxr----- prueba.txt
$ umask
0022

Qué observar en cada paso:

1. El primer stat: el fichero nace con 644. Si te sale otra cosa, tu umask no es 022 (compruébalo al final con umask).
2. Tras chmod 600: el grupo y los otros se quedan con ---. Cuenta: 6 = 4 + 2 = rw-, y dos ceros.
3. Tras chmod u+x,g+r: dos cambios en una sola orden, separados por una coma y sin espacios. El dueño pasa de 6 a 7 (6 + 1) y el grupo de 0 a 4. Resultado: 740.
4. umask: la máscara que explica el 644 del principio.

Si te atreves, añade un paso: chmod 000 prueba.txt y después cat prueba.txt. ¿Qué crees que pasará siendo tú el dueño?

Resumen

Concepto	En una línea	Ejemplo
Tres clases	dueño (u), grupo (g) y otros (o); Linux mira solo la que te corresponde	id para ver tus grupos
Diez caracteres	tipo + tres tríos rwx	drwxr-x---
Octal	r = 4, w = 2, x = 1; una cifra por trío	chmod 640 entrega.txt
Simbólico	a quién + operación + permisos	chmod u+x,g-w compilar.sh
Directorios	r = listar, w = crear y borrar, x = entrar	chmod 750 carpeta
umask	lo que se apaga al crear: 666 y 777 menos la máscara	umask 022 → 644 y 755
chown / chgrp	dueño solo con root; grupo, a uno de los tuyos	chgrp ic2 entrega.txt
Bits especiales	setuid 4, setgid 2, sticky 1 en la cifra de delante	chmod 2770 carpeta

Tres ideas para llevarte

1. Diez caracteres, cuatro piezas: tipo, dueño, grupo y otros. Linux mira solo el trío que te toca, en ese orden.
2. En una carpeta, la x es la llave de la puerta. Sin ella no entras, aunque veas los nombres.
3. La umask resta, no suma: dice qué permisos se quitan a todo lo que nace.

Con esto ya puedes leer y cambiar los permisos de cualquier cosa. En la práctica montaremos la carpeta del trabajo en grupo con permisos de verdad y la pondremos a prueba con tres usuarios: Laura, Pablo y yo. Y en el siguiente tema de Linux saldremos de los permisos para ver el shell avanzado: redirecciones, tuberías y cómo encadenar órdenes.

Siguiente paso: prácticaPermisos en Linux — práctica con la carpeta de un trabajo en grupo, tres usuarios y un revisor de permisos (y la compañera que no podía compilar)

¿Te ha servido este artículo? Así puedes apoyar SergioLearns →