File permissions and attributes (Español) - ArchWiki

Jump to content

# File permissions and attributes (Español)

From ArchWiki
Estado de la traducción: esta traducción de File permissions and attributes fue revisada el 2021-02-16. Si existen cambios puede actualizarla o avisar al equipo de traducción.

Este artículo o sección necesita ser traducido.

Notas: (2021-02) En fase de traducción. (Discusión en Talk:File permissions and attributes (Español)#)

Artículos relacionados

- Usuarios y grupos
- umask
- Listas de control de acceso
- Capabilities

Los sistemas de archivos utilizan permisos y atributos para regular el nivel de interacción que los procesos del sistema pueden tener con archivos y directorios.

Advertencia: Cuando se utilizan con fines de seguridad, los permisos y atributos solo defienden contra ataques lanzados desde el sistema iniciado. Para proteger los datos almacenados de los atacantes con acceso físico a la máquina, también se debe implementar un cifrado data-at-rest.

## Ver los permisos

Utilice la opción `-l` de la orden ls para ver los permisos (o modo de archivo) establecidos para el contenido de un directorio, por ejemplo:

    $ ls -l /path/to/directory

    total 128
    drwxr-xr-x 2 archie users  4096 Jul  5 21:03 Escritorio
    drwxr-xr-x 6 archie users  4096 Jul  5 17:37 Documentos
    drwxr-xr-x 2 archie users  4096 Jul  5 13:45 Descargas
    -rw-rw-r-- 1 archie users  5120 Jun 27 08:28 clientes.ods
    -rw-r--r-- 1 archie users  3339 Jun 27 08:28 todo
    -rwxr-xr-x 1 archie users  2048 Jul  6 12:56 miscript.sh

La primera columna es en lo que debemos enfocarnos. Tomando un valor de ejemplo de `drwxrwxrwx+`, el significado de cada carácter se explica en las siguientes tablas:

`d` | `rwx` | `rwx` | `rwx` | `+`
El tipo de archivo, técnicamente no forma parte de sus permisos. Véase `info ls -n "What information is listed"` para obtener una explicación de los posibles valores. | Los permisos que tiene el propietario sobre el archivo, explicados a continuación. | Los permisos que tiene el grupo sobre el archivo, explicados a continuación. | Los permisos que tienen todos los demás usuarios sobre el archivo, explicados a continuación. | Un solo carácter que especifica si se aplica un método de acceso alternativo al archivo. Cuando este carácter es un espacio, no existe un método de acceso alternativo. Un carácter `.` indica un archivo con un contexto de seguridad, pero ningún otro método de acceso alternativo. Un archivo con cualquier otra combinación de métodos de acceso alternativos se marca con un carácter `+`, por ejemplo en el caso de listas de control de acceso.

Cada una de las tres triadas de permisos (`rwx` en el ejemplo anterior) puede estar formada por los siguientes caracteres:

| Carácter | Efecto en archivos | Efecto en directorios
--- | --- | --- | ---
Permiso de lectura (primer carácter) | `-` | No se puede leer el archivo. | No se puede mostrar el contenido del directorio.
`r` | El archivo se puede leer. | Se puede mostrar el contenido del directorio.
Permiso de escritura (segundo carácter) | `-` | El archivo no se puede modificar. | El contenido del directorio no se puede modificar.
`w` | El archivo se puede modificar. | El contenido del directorio se puede modificar (crear nuevos archivos o carpetas; cambiar el nombre o eliminar archivos o carpetas existentes); requiere que también se establezca el permiso de ejecución; de lo contrario, este permiso no tiene ningún efecto.
Permiso de ejecución (tercer carácter) | `-` | El archivo no se puede ejecutar. | No se puede acceder al directorio con cd).
`x` | El archivo se puede ejecutar. | Se puede acceder al directorio con cd; este es el único bit de permiso que en la práctica se puede considerar "heredado" de los directorios ancestros, de hecho, si cualquier carpeta en la ruta no tiene el bit `x` establecido, tampoco se puede acceder al archivo o carpeta del final, independientemente de sus permisos; véase path_resolution(7) para obtener más información.
`s` | El bit setuid cuando se encuentra en la triada usuario; el bit setgid cuando se encuentra en la triada grupo; no se encuentra en la triada otros; también implica que `x` está establecido.
`S` | Igual que `s`, pero `x` no está configurado; raro en archivos normales e inútil en carpetas.
`t` | El bit sticky; sólo se puede encontrar en la triada otros; también implica que `x` está establecido.
`T` | Igual que `t`, pero `x` no está configurado; raro en archivos normales e inútil en carpetas.

Véase `info Coreutils -n "Mode Structure"` y chmod(1) para más detalles.

Sugerencia: Puede ver los permisos a lo largo de una ruta con `namei -l ruta`.

### Ejemplos

Veamos algunos ejemplos para aclararlo:

    drwx------ 6 archie users  4096 Jul  5 17:37 Documentos

Archie tiene acceso completo al directorio de documentos. Puede listar, crear archivos y cambiar el nombre, eliminar cualquier archivo en Documentos, independientemente de los permisos del archivo. Su capacidad para acceder a un archivo depende del permiso del mismo.

    dr-x------ 6 archie users  4096 Jul  5 17:37 Documentos

Archie tiene acceso completo, excepto que no puede crear, cambiar el nombre ni eliminar ningún archivo. Puede listar los archivos y (si el permiso del archivo lo autoriza) puede acceder a un archivo existente en Documentos.

    d-wx------ 6 archie users  4096 Jul  5 17:37 Documentos

Archie no puede hacer 'ls' en Documentos, pero si conoce el nombre de un archivo existente, entonces puede listarlo, renombrarlo, eliminarlo o (si el permiso del archivo lo autoriza) acceder a él. Además, puede crear nuevos archivos.

    d--x------ 6 archie users  4096 Jul  5 17:37 Documentos

Archie solo es capaz de (si el permiso del archivo lo autoriza) acceder a esos archivos en Documentos que conoce. No puede listar archivos ya existentes o crear, renombrar o eliminar ninguno de ellos.

Debe tener en cuenta que detallamos los permisos de directorio y no tiene nada que ver con los permisos de archivos individuales. Cuando crea un nuevo archivo, es el directorio el que cambia. Es por eso que necesita permiso de escritura en el directorio.

Veamos otro ejemplo, esta vez de un archivo, no de un directorio:

    -rw-r--r-- 1 archie users  5120 Jun 27 08:28 foobar

Aquí podemos ver que la primera letra no es `d` sino `-`. Entonces sabemos que es un archivo, no un directorio. A continuación, los permisos del propietario son `rw-` por lo que el propietario tiene la capacidad de leer y escribir, pero no ejecutar. Puede parecer extraño que el propietario no tenga los tres permisos, pero el permiso `x` no es necesario ya que es un archivo de texto/datos, para ser leído por un editor de texto como Gedit, EMACS o software como R, y no un ejecutable por derecho propio (si contuviera algo como código de programación de Python, entonces muy bien podría serlo). Los permisos del grupo están configurados en `r--`, por lo que el grupo tiene la capacidad de leer el archivo pero no escribirlo/editarlo de ninguna manera; es esencialmente como configurar algo como de solo lectura. Podemos ver que los mismos permisos se aplican también a todos los demás.

## Cambiar los permisos

chmod es una orden en Linux y otros sistemas operativos similares a Unix que permite cambiar los permisos (o acceder al modo) de un archivo o directorio.

### Método de texto

Para cambiar los permisos (o el "modo de acceso") de un archivo, utilice la orden chmod en una terminal. A continuación se muestra la estructura general de la orden:

    chmod quién=permisos archivo

Donde `quién` es cualquier variedad de letras, cada una de las cuales significa a quién se le está dando el permiso. Son los siguientes:

- `u`: el usuario que es dueño del archivo.
- `g`: el grupo al que pertenece el archivo.
- `o`: los otros usuarios, es decir, todos los demás.
- `a`: (all), todo lo anterior; utilice esto en lugar de escribir `ugo`.

Los permisos son los mismos que se discutieron en #Ver los permisos (`r`, `w` y `x`).

Now have a look at some examples using this command. Suppose you became very protective of the Documents directory and wanted to deny everybody but yourself, permissions to read, write, and execute (or in this case search/look) in it:

Before: `drwxr-xr-x 6 archie users 4096 Jul 5 17:37 Documents`

    $ chmod g= Documents
    $ chmod o= Documents

After: `drwx------ 6 archie users 4096 Jul 6 17:32 Documents`

Here, because you want to deny permissions, you do not put any letters after the `=` where permissions would be entered. Now you can see that only the owner's permissions are `rwx` and all other permissions are `-`.

This can be reverted with:

Before: `drwx------ 6 archie users 4096 Jul 6 17:32 Documents`

    $ chmod g=rx Documents
    $ chmod o=rx Documents

After: `drwxr-xr-x 6 archie users 4096 Jul 6 17:32 Documents`

In the next example, you want to grant read and execute permissions to the group, and other users, so you put the letters for the permissions (`r` and `x`) after the `=`, with no spaces.

You can simplify this to put more than one `who` letter in the same command, e.g:

    $ chmod go=rx Documents

Nota: It does not matter in which order you put the `who` letters or the permission letters in a `chmod` command: you could have `chmod go=rx file` or `chmod og=xr file`. It is all the same.

Now let us consider a second example, suppose you want to change a `foobar` file so that you have read and write permissions, and fellow users in the group `users` who may be colleagues working on `foobar`, can also read and write to it, but other users can only read it:

Before: `-rw-r--r-- 1 archie users 5120 Jun 27 08:28 foobar`

    $ chmod g=rw foobar

After: `-rw-rw-r-- 1 archie users 5120 Jun 27 08:28 foobar`

This is exactly like the first example, but with a file, not a directory, and you grant write permission (just so as to give an example of granting every permission).

#### Text method shortcuts

The chmod command lets add and subtract permissions from an existing set using `+` or `-` instead of `=`. This is different from the above commands, which essentially re-write the permissions (e.g. to change a permission from `r--` to `rw-`, you still need to include `r` as well as `w` after the `=` in the chmod command invocation. If you missed out `r`, it would take away the `r` permission as they are being re-written with the `=`. Using `+` and `-` avoids this by adding or taking away from the current set of permissions).

Let us try this `+` and `-` method with the previous example of adding write permissions to the group:

Before: `-rw-r--r-- 1 archie users 5120 Jun 27 08:28 foobar`

    $ chmod g+w foobar

After: `-rw-rw-r-- 1 archie users 5120 Jun 27 08:28 foobar`

Another example, denying write permissions to all (a):

Before: `-rw-rw-r-- 1 archie users 5120 Jun 27 08:28 foobar`

    $ chmod a-w foobar

After: `-r--r--r-- 1 archie users 5120 Jun 27 08:28 foobar`

A different shortcut is the special `X` mode: this is not an actual file mode, but it is often used in conjunction with the `-R` option to set the executable bit only for directories, and leave it unchanged for regular files, for example:

    $ chmod -R a+rX ./data/

#### Copying permissions

It is possible to tell chmod to copy the permissions from one class, say the owner, and give those same permissions to group or even all. To do this, instead of putting `r`, `w`, or `x` after the `=`, put another who letter. e.g:

Before: `-rw-r--r-- 1 archie users 5120 Jun 27 08:28 foobar`

    $ chmod g=u foobar

After: `-rw-rw-r-- 1 archie users 5120 Jun 27 08:28 foobar`

This command essentially translates to "change the permissions of group (`g=`), to be the same as the owning user (`=u`). Note that you cannot copy a set of permissions as well as grant new ones e.g.:

    $ chmod g=wu foobar

In that case chmod throw an error.

### Numeric method

chmod can also set permissions using numbers.

Using numbers is another method which allows you to edit the permissions for all three owner, group, and others at the same time, as well as the setuid, setgid, and sticky bits. This basic structure of the code is this:

    $ chmod xxx filename

Where `xxx` is a 3-digit number where each digit can be anything from 0 to 7. The first digit applies to permissions for owner, the second digit applies to permissions for group, and the third digit applies to permissions for all others.

In this number notation, the values `r`, `w`, and `x` have their own number value:

    r=4
    w=2
    x=1

To come up with a 3-digit number you need to consider what permissions you want owner, group, and all others to have, and then total their values up. For example, if you want to grant the owner of a directory read write and execution permissions, and you want group and everyone else to have just read and execute permissions, you would come up with the numerical values like so:

- Owner: `rwx`=4+2+1=7
- Group: `r-x`=4+0+1=5
- Other: `r-x`=4+0+1=5

    $ chmod 755 filename

This is the equivalent of using the following:

    $ chmod u=rwx filename
    $ chmod go=rx filename

To view the existing permissions of a file or directory in numeric form, use the stat(1) command:

    $ stat -c %a filename

Where the %a option specifies output in numeric form.

Most folders and directories are set to `755` to allow reading, writing and execution to the owner, but deny writing to everyone else, and files are normally `644` to allow reading and writing for the owner but just reading for everyone else; refer to the last note on the lack of `x` permissions with non executable files: it is the same thing here.

To see this in action with examples consider the previous example that has been used but with this numerical method applied instead:

Before: `-rw-r--r-- 1 archie users 5120 Jun 27 08:28 foobar`

    $ chmod 664 foobar

After: `-rw-rw-r-- 1 archie users 5120 Jun 27 08:28 foobar`

If this were an executable the number would be `774` if you wanted to grant executable permission to the owner and group. Alternatively if you wanted everyone to only have read permission the number would be `444`. Treating `r` as 4, `w` as 2, and `x` as 1 is probably the easiest way to work out the numerical values for using `chmod xxx filename`, but there is also a binary method, where each permission has a binary number, and then that is in turn converted to a number. It is a bit more convoluted, but here included for completeness.

Consider this permission set:

    -rwxr-xr--

If you put a 1 under each permission granted, and a 0 for every one not granted, the result would be something like this:

    -rwxrwxr-x
     111111101

You can then convert these binary numbers:

    000=0	    100=4
    001=1	    101=5
    010=2	    110=6
    011=3	    111=7

The value of the above would therefore be 775.

Consider we wanted to remove the writable permission from group:

    -rwxr-xr-x
     111101101

The value would therefore be 755 and you would use `chmod 755 filename` to remove the writable permission. You will notice you get the same three digit number no matter which method you use. Whether you use text or numbers will depend on personal preference and typing speed. When you want to restore a directory or file to default permissions e.g. read and write (and execute) permission to the owner but deny write permission to everyone else, it may be faster to use `chmod 755/644 filename`. However if you are changing the permissions to something out of the norm, it may be simpler and quicker to use the text method as opposed to trying to convert it to numbers, which may lead to a mistake. It could be argued that there is not any real significant difference in the speed of either method for a user that only needs to use chmod on occasion.

You can also use the numeric method to set the `setuid`, `setgid`, and `sticky` bits by using four digits.

    setuid=4
    setgid=2
    sticky=1

For example, `chmod 2777 filename` will set read/write/executable bits for everyone and also enable the `setgid` bit.

### Bulk chmod

Generally directories and files should not have the same permissions. If it is necessary to bulk modify a directory tree, use find to selectively modify one or the other.

To chmod only directories to 755:

    $ find directory -type d -exec chmod 755 {} +

To chmod only files to 644:

    $ find directory -type f -exec chmod 644 {} +

## Changing ownership

chown changes the owner of a file or directory, which is quicker and easier than altering the permissions in some cases.

Consider the following example, making a new partition with GParted for backup data. Gparted does this all as root so everything belongs to root by default. This is all well and good but when it comes to writing data to the mounted partition, permission is denied for regular users.

    brw-rw---- 1 root disk 8,    9 Jul  6 16:02 sda9
    drwxr-xr-x 5 root root    4096 Jul  6 16:01 Backup

As you can see the device in `/dev` is owned by root, as is the mount location (`/media/Backup`). To change the owner of the mount location one can do the following:

Before: `drwxr-xr-x 5 root root 4096 Jul 6 16:01 Backup`

    # chown archie /media/Backup

After: `drwxr-xr-x 5 archie root 4096 Jul 6 16:01 Backup`

Now the partition can have data written to it by the new owner, archie, without altering the permissions (as the owner triad already had `rwx` permissions).

Nota:

- `chown` always clears the setuid and setgid bits.
- Non-root users cannot use `chown` to "give away" files they own to another user.

## Access Control Lists

Access Control Lists provides an additional, more flexible permission mechanism for file systems by allowing to set permissions for any user or group to any file.

## Umask

The umask utility is used to control the file-creation mode mask, which determines the initial value of file permission bits for newly created files.

## File attributes

Apart from the file mode bits that control user and group read, write and execute permissions, several file systems support file attributes that enable further customization of allowable file operations. This section describes some of these attributes and how to work with them.

Advertencia: By default, file attributes are not preserved by cp, rsync, and other similar programs.

### chattr and lsattr

For ext2 and ext3 file systems, the e2fsprogs package contains the programs lsattr and chattr that list and change a file's attributes, respectively. Though some are not honored by all file systems, the available attributes are:

- `a`: append only
- `c`: compressed
- `d`: no dump
- `e`: extent format
- `i`: immutable
- `j`: data journalling
- `s`: secure deletion
- `t`: no tail-merging
- `u`: undeletable
- `A`: no atime updates
- `C`: no copy on write
- `D`: synchronous directory updates
- `S`: synchronous updates
- `T`: top of directory hierarchy

For example, if you want to set the immutable bit on some file, use the following command:

    # chattr +i /path/to/file

To remove an attribute on a file just change `+` to `-`.

## Extended attributes

From xattr(7): "Extended attributes are name:value pairs associated permanently with files and directories". There are four extended attribute classes: security, system, trusted and user.

Advertencia: By default, extended attributes are not preserved by cp, rsync, and other similar programs, see #Preserving extended attributes.

Extended attributes are also used to set Capabilities.

### User extended attributes

User extended attributes can be used to store arbitrary information about a file. To create one:

    $ setfattr -n user.checksum -v "3baf9ebce4c664ca8d9e5f6314fb47fb" foo.txt

Use getfattr to display extended attributes:

    $ getfattr -d foo.txt

    # file: foo.txt
    user.checksum="3baf9ebce4c664ca8d9e5f6314fb47fb"

Finally, to remove an extended attribute:

    $ setfattr -x user.checksum foo.txt

### Preserving extended attributes

Command | Required flag
--- | ---
`cp` | `--preserve=mode,ownership,timestamps,xattr`
`mv` | preserves by default1
`tar` | `--xattrs` for creation and extraction
`bsdtar` | `-p` for extraction
rsync | `--xattrs`

1. mv silently discards extended attributes when the target file system does not support them.

To preserve extended attributes with text editors you need to configure them to truncate files on saving instead of using rename(2).[1]

## Tips and tricks

### Preserve root

Use the `--preserve-root` flag to prevent `chmod` from acting recursively on `/`. This can, for example, prevent one from removing the executable bit systemwide and thus breaking the system. To use this flag every time, set it within an alias. See also [2].

## See also

- wikipedia:Chattr
- Linux File Permission Confusion
- Linux File Permission Confusion part 2
- wikipedia:Extended file attributes#Linux
- Extended attributes: the good, the not so good, the bad.
- Backup and restore file permissions in Linux
- Why is “chmod -R 777 /” destructive?

Categories:

- File systems (Español)
- Command-line (Español)

Hidden category:

- Pages or sections flagged with Template:Translateme (Español)