En informática, umask
es un comando que determina la configuración de una máscara que controla cómo se establecen los permisos de archivo para los archivos recién creados. También puede afectar cómo se cambian explícitamente los permisos de archivo. umask
también es una función que establece la máscara, o puede referirse a la máscara en sí, que se conoce formalmente como la 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 umask
comando.
Versión inicial | 1978 |
---|---|
Sistema operativo | Unix y similar a Unix |
Plataforma | Multiplataforma |
Tipo | Mando |
Descripción general
En los sistemas similares a 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", el permiso de archivo inicial correspondiente se desactivará . Un bit establecido en "0" en la máscara significa que el programa y el sistema de archivos determinarán el permiso correspondiente . 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 un "1" elimina su permiso correspondiente. Los permisos pueden ser cambiados más tarde por los usuarios y los programas que utilizan chmod
.
Cada programa (técnicamente llamado proceso ) tiene su propia máscara y puede cambiar su configuración mediante una llamada de función. Cuando el proceso es un shell , la máscara se establece con el umask
comando. 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 ningún efecto cuando se cambian los permisos de archivo en archivos existentes; sin embargo, el chmod
comando comprobará la máscara cuando las opciones de modo se especifiquen utilizando 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ólica . El umask
comando permite establecer la máscara como notación octal (p 0754
. Ej. ) O simbólica (p u=,g=w,o=wx
. Ej. ).
El umask
comando se usa con sistemas operativos similares a Unix y la umask
función se define en la especificación POSIX.1 .
Historia
La máscara, el umask
comando y la umask
funció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. Eventualmente creció para servir 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 casos de brechas de seguridad reales, pero esta no era una solución general. La máscara y el umask
comando se introdujeron alrededor de 1978, en la séptima edición del sistema operativo, [1] para permitir que los sitios, grupos e individuos elijan 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.
Comando de Shell
En un shell, la máscara se establece mediante el umask
comando. La sintaxis del comando es: [2]
umask [ -S ] [ maskExpression ]
(Los elementos entre paréntesis son opcionales).
Visualización de la máscara actual
Si el umask
comando se invoca sin ningún argumento, 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 -S
argumento (es decir umask -S
) indicará umask
que se muestre usando 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
Configurar la máscara usando notación octal
Si el umask
comando se invoca 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 part of mask
$ umask -S # mostrar la máscara simbólicamente u = rwx, g = rwx, o =
Si se ingresan menos de 4 dígitos, se asumen 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 más a la derecha se refieren a las clases de usuario "propietario", "grupo" y "otras", respectivamente. Si hay un cuarto dígito presente, el dígito más a la izquierda (de orden superior) aborda tres atributos adicionales, el bit setuid , el bit setgid y el bit adhesivo .
Códigos octales
Dígito octal al umask mando | Permisos que la máscara prohibirá que se establezcan durante la creación del archivo |
---|---|
0 | se puede establecer cualquier permiso (leer, escribir, ejecutar) |
1 | la configuración del permiso de ejecución está prohibida (lectura y escritura) |
2 | la configuración del permiso de escritura está prohibida (lectura y ejecución) |
3 | la configuración del permiso de escritura y ejecución está prohibida (solo lectura) |
4 | la configuración del permiso de lectura está prohibida (escribir y ejecutar) |
5 | la configuración del permiso de lectura y ejecución está prohibida (solo escritura) |
6 | la configuración de permisos de lectura y escritura está prohibida (solo ejecutar) |
7 | se prohíbe configurar todos los permisos (sin permisos) |
Configurar la máscara usando notación simbólica
Cuando umask
se invoca usando notación simbólica, modificará o establecerá las banderas según lo especificado por maskExpression con la sintaxis:
Tenga en cuenta que esta sintaxis no funciona cuando se usa el shell C debido al comportamiento diferente de su umask
comando incorporado .
Varias expresiones de máscara están separadas por comas.
Un espacio termina la (s) maskExpression (s).
Los permisos se aplican a diferentes clases de usuarios:
Letra | Clase | Descripción |
---|---|---|
u | usuario | el propietario |
g | grupo | usuarios que son miembros del grupo del archivo |
o | otros | usuarios que no son el propietario del archivo o miembros del grupo |
a | todas | los tres de los anteriores, lo mismo que ugo . (El valor predeterminado si no se especifican letras de clase de usuario en maskExpression ). |
El operador especifica cómo se deben ajustar los modos de permiso de la máscara.
Operador | Efecto sobre la máscara |
---|---|
+ | los permisos especificados están habilitados, los permisos que no se especifican no se modifican. |
- | los permisos especificados no se pueden habilitar, los permisos que no se especifican no se modifican. |
= | los permisos especificados están habilitados, los permisos que no están especificados no pueden habilitarse. |
Los símbolos de permiso indican qué configuración de permisos de archivo debe permitir o prohibir la máscara.
Símbolo | Nombre | Descripción |
---|---|---|
r | leer | r ead un archivo o mostrar el contenido de un directorio |
w | escribir | w rito a un archivo o directorio |
x | ejecutar | e x ecuar un archivo o recurrir a un árbol de directorios |
X | ejecución especial | Consulte Modos simbólicos . |
s | setuid / gid | Consulte Permisos de archivo . |
t | pegajoso | Consulte Permisos de archivo. |
Por ejemplo:
umask uw
Prohibir w permiso rito de ser fijada para la U SER. El resto de las banderas de la máscara no se modifican.
Ejemplo de múltiples cambios:
umask uw, g = r, o + r
Esto establecería la máscara para que:
- prohibir la w permiso rito de ser fijada para la U Ser, dejando el resto de las banderas sin cambios;
- permite la r permiso ead para estar habilitado para el g rupo, mientras que prohíbe w rito y e x ecute permiso para que el g rupo;
- permiten que el r permiso EAD para estar habilitado para O tros, dejando el resto de la O tros banderas sin cambios.
Ejemplos de línea de comando
Aquí hay más ejemplos de cómo usar el umask
comando para cambiar la máscara:
umask comando emitido | Cómo afectará la máscara a los permisos de los archivos / directorios creados posteriormente |
---|---|
umask a+r | permite habilitar el permiso de lectura para todas las clases de usuarios; el resto de los bits de la máscara no se modifican |
umask a-x | prohíbe la habilitación de permisos de ejecución para todas las clases de usuarios; el resto de los bits de la máscara no se modifican |
umask a+rw | permite habilitar el permiso de lectura o escritura para todas las clases de usuarios; el resto de los bits de la máscara no se modifican |
umask +rwx | permite habilitar permisos de lectura, escritura o ejecución para todas las clases de usuarios. (Nota: en algunas plataformas UNIX, esto restaurará la máscara a su valor predeterminado). |
umask u=rw,go= | permitir que los permisos de lectura y escritura estén habilitados para el propietario, mientras que prohíbe que el permiso de ejecución esté habilitado para el propietario; prohibir la habilitación de permisos para el grupo y otros |
umask u+w,go-w | permitir que se habilite el permiso de escritura para el propietario; prohibir que se habilite el permiso de escritura para el grupo y otros; |
umask -S | mostrar la máscara actual en notación simbólica |
umask 777 | no permitir leer, escribir y ejecutar permisos para todos (¡probablemente no sea útil porque incluso el propietario no puede leer archivos creados con esta máscara!) |
umask 000 | Permitir permiso de lectura, escritura y ejecución para todos (riesgo potencial de seguridad) |
umask 077 | Permitir el permiso de lectura, escritura y ejecución para el propietario del archivo, pero prohibir el permiso de lectura, escritura y ejecución para todos los demás. |
umask 113 | permitir que se habilite el permiso de lectura o escritura para el propietario y el grupo, pero no el permiso de ejecución; permitir que el permiso de lectura esté habilitado para otros, pero no el permiso de escritura o ejecución |
umask 0755 | equivalente a u-rwx,go=w . ( 0 Especifica que los modos especiales (setuid, setgid, sticky) pueden estar habilitados). |
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 desarrollador 6010 10 de julio 17:10 a.out $ # el umask prohibido Permiso de escritura para grupos y otros $ ls> listOfMyFiles # archivo de salida creado por redirección no intenta establecer eXecute $ ls -l listOfMyFiles -rw-r-- r-- 1 yo desarrollador 6010 10 de julio 17:14 listOfMyFiles $ # el umask prohibido Permiso de escritura para el grupo y otros $ ######################################################################################################################################################################################################################################### ################################## $ umask uw # eliminar el permiso de escritura del usuario de umask $ umask -S u = rx, g = rx, o = rx $ ls> protectedListOfFiles $ ls -l protectedListOfFiles -r - r - r-- 1 desarrollador de mí 6010 10 de julio 17:15 protectedListOfFiles $ rm protectedListOfFiles anula r - r - r - yo / desarrollador para protectedListOfFiles? $ # advertencia de que protectedListOfFiles no se puede escribir, al responder Y se eliminará el archivo $ ######################################################################################################################################################################################################################################################################### ############################################################################################################################################################################################################################################################################################ # $ umask gr, o # grupo eliminado leído y otro leído de la máscara $ umask -S u = rx, g = x, o = x $ ls> secretListOfFiles $ ls -l secretListOfFiles -r -------- 1 yo desarrollador 6010 10 de julio 17:16 secretListOfFiles
Efecto máscara
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 los archivos se creen posteriormente. Un bit establecido en "0" en la máscara significa que el proceso de solicitud y el sistema operativo determinarán el permiso correspondiente cuando se creen los 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 un "1" elimina el permiso correspondiente para el archivo.
Mesa de la verdad
Aquí está la tabla de verdad para la lógica de enmascaramiento. Cada bit en el modo de permiso de archivo del proceso solicitante es operado por la máscara usando esta lógica para producir el modo de permiso que se aplica al archivo a medida que se crea. ( p es un bit en el modo de permiso de archivo solicitado de un proceso que está creando un archivo; q es un bit en la máscara; r es el bit resultante en el modo de permiso del archivo creado)
pag | q | r |
---|---|---|
T | T | F |
T | F | T |
F | T | F |
F | F | F |
Cómo se aplica la mascarilla
Dígito octal al umask mando | Binario en la máscara | Negación de máscara | AND lógico con solicitud "rwx" [5] |
---|---|---|---|
0 | 000 | 111 | rwx |
1 | 001 | 110 | rw- |
2 | 010 | 101 | rx |
3 | 011 | 100 | r-- |
4 | 100 | 011 | -wx |
5 | 101 | 010 | -w- |
6 | 110 | 001 | --X |
7 | 111 | 000 | --- |
Programáticamente, el sistema operativo aplica la máscara al primero negar (complementar) la máscara y luego realizar un AND lógico con el modo de archivo solicitado. En el [probablemente] primer manual de UNIX para describir su función, [6] el manual dice,
el modo real ... del archivo recién creado es el lógico y 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 apagarán cuando se creen los archivos.
- Manual UNIX octava edición, Bell Labs UNIX (manual), AT&T Laboratories
En lógica booleana, la aplicación de la máscara se puede representar como:C: (P&(~Q))
Esto dice que el modo de permiso del archivo (C) es el resultado de una operación lógica Y entre la negación de la máscara (Q) y la configuración del modo de permiso solicitado del proceso (P).
Excepciones
Muchos sistemas operativos no permiten la creación de un archivo 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 solo se aplica a funciones que crean un nuevo archivo; sin embargo, existen excepciones. Por ejemplo, cuando se usan las versiones UNIX y GNU de chmod
para establecer los permisos de un archivo, y se usa 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 de archivo $ ls -l nombre de archivo -rwxrwxrwx nombre de archivo $ umask 0022 $ chmod + rwx nombre de archivo $ ls -l nombre de archivo -rwxr-xr-x nombre de archivo
Procesos
Cada proceso tiene su propia máscara, que se aplica cada vez 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 , el umask
comando cambia la máscara . Al igual que con otros procesos, cualquier proceso iniciado desde el shell hereda la máscara de ese shell.
Opción de montaje
En el núcleo de Linux , la fat
, hfs
, hpfs
, ntfs
, y udf
del sistema de archivos controladores soportan una umask
opción de montaje , que controla la forma en la información del disco se asigna a los permisos. 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 fmask
.
Ver también
- Permisos del sistema de archivos
Referencias
- ^ "Manual de la séptima edición de UNIX, Bell Labs UNIX" . Manual . Laboratorios AT&T . Consultado el 14 de mayo de 2019 .
- ^ Olczak, Anatole (9 de junio de 2019). "Korn Shell: Manual de programación de Unix y Linux" . Oreilly . Addison-Wesley Professional . Consultado el 14 de enero de 2013 .
- ^ "umask", The Single UNIX Specification, Versión 2 (manual), The Open Group, 1997 , consultado el 14 de enero de 2013
- ^ Nota: Algunos lenguajes de programación requieren un símbolo de prefijo delante de la notación octal, como el dígito 0 o las letras o o q. El
umask
comando no usa este tipo de notación de prefijo, solo se usan los dígitos octales. - ^ Nota: Los sistemas operativos generalmente también eliminarán los permisos de ejecución en los archivos recién creados.
- ^ "Manual de UNIX octava edición, Bell Labs UNIX" . Manual . Laboratorios AT&T . Consultado el 14 de enero de 2013 .
- ^ "umask (2)", del Programador de Linux versión 3.32 Manual (Manual), Linux-hombre páginas del proyecto 9 de enero 2008 , recuperada 2013-01-01