máscara de usuario

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Umask" – news · newspapers · books · scholar · JSTOR (March 2017) (Learn how and when to remove this message)

En informática, umaskes un comando que determina la configuración de una máscara que controla cómo se establecen los permisos de archivoumask para los archivos recién creados. También puede afectar la forma en que se cambian explícitamente los permisos de archivo. también es una función que establece la máscara, o puede hacer referencia a la máscara en sí, que se conoce formalmente como máscara de creación del modo de archivo . La máscara es una agrupación de bits , cada uno de los cuales restringe cómo se establece su permiso correspondiente para los archivos recién creados. Los bits de la máscara se pueden cambiar invocando el umaskcomando.

En sistemas tipo Unix , cada archivo tiene un conjunto de atributos que controlan quién puede leerlo, escribirlo o ejecutarlo. Cuando un programa crea un archivo, los permisos del archivo están restringidos por la máscara. Si la máscara tiene un bit establecido en "1", entonces el permiso de archivo inicial correspondiente estará deshabilitado . Un bit establecido en "0" en la máscara significa que el permiso correspondiente será determinado por el programa y el sistema de archivos . En otras palabras, la máscara actúa como un filtro de última etapa que elimina los permisos a medida que se crea un archivo; cada bit que se establece en "1" elimina su permiso correspondiente. Los permisos pueden ser cambiados más tarde por los usuarios y los programas que utilicen chmod.

Cada programa (técnicamente llamado proceso ) tiene su propia máscara y puede cambiar sus configuraciones mediante una llamada de función. Cuando el proceso es un shell , la máscara se establece con el umaskcomando. Cuando un shell o proceso lanza un nuevo proceso, el proceso hijo hereda la máscara de su proceso padre. Generalmente, la máscara solo afecta los permisos de archivo durante la creación de nuevos archivos y no tiene efecto cuando se cambian los permisos de archivo en archivos existentes; sin embargo, el chmodcomando verificará la máscara cuando las opciones de modo se especifiquen mediante el modo simbólico y no se especifique una referencia a una clase de usuarios.

La máscara se almacena como un grupo de bits. Puede representarse como notación binaria , octal o simbólicaumask . El comando permite configurar la máscara como notación octal (eg 0754) o simbólica (eg u=,g=w,o=wx).

El umaskcomando se utiliza con sistemas operativos tipo Unix y la umaskfunción está definida en la especificación POSIX.1 .

La máscara, el umaskcomando y la umaskfunción no formaban parte de la implementación original de UNIX . El sistema operativo evolucionó en un entorno de centro informático relativamente pequeño, donde la seguridad no era un problema. Con el tiempo, creció hasta dar servicio a cientos de usuarios de diferentes organizaciones. Al principio, los desarrolladores hicieron que los modos de creación de archivos clave fueran más restrictivos, especialmente para los casos de violaciones de seguridad reales, pero esta no fue una solución general. La máscara y el umaskcomando se introdujeron alrededor de 1978, en la séptima edición del sistema operativo, ^[1] para que pudiera permitir a los sitios, grupos e individuos elegir sus propios valores predeterminados. Desde entonces, la máscara se ha implementado en la mayoría, si no en todas, las implementaciones contemporáneas de sistemas operativos similares a Unix.

En un shell, la máscara se configura mediante el umaskcomando. La sintaxis del comando es: ^[2]

umask [ -S ] [ expresión de máscara ]   

(Los elementos entre paréntesis son opcionales).

Si umaskse invoca el comando sin argumentos, se mostrará la máscara actual. La salida estará en notación octal o simbólica , según el sistema operativo. ^[3]

En la mayoría de los shells , pero no en el shell C , el -Sargumento (ie umask -S) indicará umaskque se debe mostrar mediante notación simbólica. Por ejemplo:

$ umask # muestra el valor actual (como octal) 0022
$ umask -S # muestra el valor actual simbólicamente u = rwx,g = rx,o = rx     

Si se invoca el umaskcomando con un argumento octal, establecerá directamente los bits de la máscara en ese argumento:

$ umask 007 # establece la máscara en 007
$ umask # muestra la máscara (en octal) 0007 # 0 - permisos especiales (setuid | setgid | sticky) # 0 - (u)ser/propietario parte de la máscara # 0 - (g)roup parte de la máscara # 7 - (o)thers/not-in-group parte de la máscara
$ umask -S # muestra la máscara simbólicamente u = rwx,g = rwx,o =            

Si se introducen menos de 4 dígitos, se supone que hay ceros a la izquierda. Se producirá un error si el argumento no es un número octal válido o si tiene más de 4 dígitos. ^[4] Los tres dígitos octales situados más a la derecha se refieren a las clases de usuario "propietario", "grupo" y "otro", respectivamente. Si hay un cuarto dígito, el dígito situado más a la izquierda (de orden superior) se refiere a tres atributos adicionales: el bit setuid , el bit setgid y el bit sticky .

Cuando umaskse invoca utilizando notación simbólica, modificará o establecerá los indicadores según lo especificado por maskExpression con la sintaxis:

Tenga en cuenta que esta sintaxis no funciona cuando se utiliza C shell debido al comportamiento diferente de su comando incorporado umask.

Varias maskExpressions se separan mediante comas.

Un espacio termina la (s) maskExpression (s).

Los permisos se aplican a diferentes clases de usuarios:

El operador especifica cómo se deben ajustar los modos de permiso de la máscara.

Los símbolos de permiso indican qué configuraciones de permisos de archivo deben permitirse o prohibirse mediante la máscara.

Por ejemplo:

máscara de usuario  u-w

Prohíba que se le otorgue permiso de escritura al usuario . El resto de los indicadores de la máscara no se modifican.

Ejemplo de cambios múltiples:

máscara  u-w,g = r,o+r

Esto configuraría la máscara de modo que:

1. prohibir que se establezca el permiso de escritura para el usuario , mientras que el resto de las banderas permanecen sin cambios;
2. permitir que se habilite el permiso de lectura para el grupo , mientras se prohíbe el permiso de escritura y ejecución para el grupo ;
3. permitir que el permiso de lectura esté habilitado para otros , mientras que el resto de las otras banderas permanecen sin cambios.

A continuación se muestran más ejemplos del uso del umaskcomando para cambiar la máscara:

Ejemplo que muestra el efecto de umask:

$ umask  -S # Muestra la configuración (frecuentemente inicial) u=rwx,g=rx,o=rx $ gcc hello.c # Compila y crea el archivo ejecutable a.out $ ls -l a.out -rwxr-xr-x 1 me developer 6010 Jul 10 17:10 a.out $ # La umask prohíbe el permiso de escritura para el grupo y otros $ ls > listOfMyFiles # El archivo de salida creado por redirección no intenta establecer eXecute $ ls -l listOfMyFiles -rw-r--r-- 1 me developer 6010 Jul 10 17:14 listOfMyFiles $ # La umask prohíbe el permiso de escritura para el grupo y otros $ ############################################################### $ umask u-w # eliminar permiso de escritura del usuario de umask $ umask -S u=rx,g=rx,o=rx $ ls > protectedListOfFiles $ ls -l protectedListOfFiles -r--r--r-- 1 me developer 6010 Jul 10 17:15 protectedListOfFiles $ rm protectedListOfFiles anular r--r--r-- me/developer para protectedListOfFiles? $ # advertencia de que protectedListOfFiles no es escribible, al responder Y se eliminará el archivo $ ############################################################################################ $ umask g-r,or # lectura de grupo eliminada y otras lecturas de la máscara $ umask -S u=rx,g=x,o=x $ ls > secretListOfFiles $ ls -l secretListOfFiles -r-------- 1 me developer 6010 Jul 10 17:16 secretListOfFiles                          

La máscara se aplica siempre que se crea un archivo. Si la máscara tiene un bit establecido en "1", eso significa que el permiso de archivo correspondiente siempre estará deshabilitado cuando se creen archivos posteriormente. Un bit establecido en "0" en la máscara significa que el permiso correspondiente será determinado por el proceso solicitante y el sistema operativo cuando se creen archivos posteriormente. En otras palabras, la máscara actúa como un filtro de última etapa que elimina los permisos a medida que se crea un archivo; cada bit que se establece en "1" elimina ese permiso correspondiente para el archivo.

Programáticamente, el sistema operativo aplica la máscara negando (complementando) primero la máscara y luego realizando un AND lógico con el modo de archivo solicitado. En el [probablemente] primer manual de UNIX que describe su función, ^[6] el manual dice:

El modo actual... del archivo recién creado es el y lógico del modo dado y el complemento del argumento. Solo participan los 9 bits de orden inferior de la máscara (los bits de protección). En otras palabras, la máscara muestra [indica] los bits que se deben desactivar cuando se crean los archivos.

—  Manual de UNIX octava edición, Bell Labs UNIX (manual), AT&T Laboratories

Muchos sistemas operativos no permiten crear archivos con permisos de ejecución. En estos entornos, los archivos recién creados siempre tendrán el permiso de ejecución deshabilitado para todos los usuarios.

La máscara generalmente se aplica únicamente a funciones que crean un nuevo archivo; sin embargo, existen excepciones. Por ejemplo, cuando se utilizan versiones de UNIX y GNUchmod para establecer los permisos de un archivo, y se utiliza notación simbólica y no se especifica ningún usuario, la máscara se aplica a los permisos solicitados antes de que se apliquen al archivo. Por ejemplo:

$ umask 0000 $ chmod +rwx nombre_archivo $ ls -l nombre_archivo -rwxrwxrwx nombre_archivo $ umask 0022 $ chmod +rwx nombre_archivo $ ls -l nombre_archivo -rwxr-xr-x nombre_archivo          

Cada proceso tiene su propia máscara, que se aplica siempre que el proceso crea un nuevo archivo. Cuando un shell, o cualquier otro proceso, genera un nuevo proceso, el proceso hijo hereda la máscara de su proceso padre. ^[7] Cuando el proceso es un shell , la máscara se cambia mediante el umaskcomando. Al igual que con otros procesos, cualquier proceso lanzado desde el shell hereda la máscara de ese shell.

En el núcleo de Linux , los controladores del sistema de archivosfat , hfs, hpfs, ntfsy admiten una opción de montaje que controla cómo se asigna la información del disco a los permisos. Esto no es lo mismo que la máscara por proceso descrita anteriormente, aunque los permisos se calculan de manera similar. Algunos de estos controladores del sistema de archivos también admiten máscaras independientes para archivos y directorios, utilizando opciones de montaje como .udf umask fmask

La Guía Wikilibro de Unix tiene una página sobre el tema: Comandos

• Permisos del sistema de archivos