Comando umask: permissões seguras por omissão no Linux

Crie um ficheiro novo num servidor Linux e repare nas permissões com que nasce: quase sempre -rw-r--r--, legível por qualquer conta da máquina. Ninguém correu um chmod. Quem decidiu foi o umask, uma máscara discreta que se aplica a tudo o que é criado — configurações, cópias de segurança, exportações de dados. Tem um enorme impacto na segurança e é muitas vezes esquecida.

Neste artigo vemos como ler a máscara, porque é que ela mascara bits em vez de subtrair, quando usar 022, 027, 077 ou 002, a notação simbólica e como torná-la persistente — na sua conta, no sistema e nos serviços do systemd.

Veja o guia em vídeo

Prefere ver antes de experimentar? No canal HJFR-IT no YouTube mostramos o umask opção a opção, com o resultado de cada comando no ecrã — narrado em português e com legendas.

O que faz o umask

Enquanto o chmod muda as permissões de um ficheiro que já existe, o umask decide as dos ficheiros que ainda vão ser criados. É um comando interno da shell que lê ou altera a máscara do processo atual, herdada por tudo o que essa shell lançar. A máscara nunca acrescenta permissões: indica apenas as que devem ser retiradas no momento da criação.

umask            # mostra a máscara atual, em octal
umask -S         # mostra a mesma máscara em notação simbólica
umask -p         # mostra-a na forma de comando: umask 0022
umask MODO       # define uma máscara nova (octal ou simbólica)

Ver a máscara: umask e umask -S

Escrito sozinho, o umask mostra a máscara atual — tipicamente 0022, o valor mais comum. São dígitos octais, como no chmod, mas com o sentido invertido: cada bit ligado é uma permissão retirada. O primeiro zero corresponde aos bits especiais, que o umask não usa na prática; os três seguintes são dono, grupo e outros.

Para ler sem fazer contas, o -S (S maiúsculo) mostra a mesma máscara em notação simbólica — e pela positiva, descrevendo o que fica permitido:

$ umask
0022
$ umask -S
u=rwx,g=rx,o=rx

O dono pode ter tudo; o grupo e os outros, leitura e execução, mas não escrita. Se numa conta normal de um Debian ou Ubuntu atual vir 0002, é efeito dos grupos privados por utilizador (USERGROUPS_ENAB yes no /etc/login.defs): o pam_umask dá ao grupo as permissões do dono. O root e os serviços continuam em 0022.

Como funciona: mascarar bits, não subtrair

Os programas pedem ao núcleo um modo de partida: 666 (rw-rw-rw-) para ficheiros e 777 (rwxrwxrwx) para diretórios — um ficheiro de texto não deve nascer executável, mas num diretório o x é preciso para entrar. O núcleo pega nesse pedido e desliga todos os bits ligados na máscara: modo & ~umask.

• Com 022, os ficheiros ficam em 644 (rw-r--r--) e os diretórios em 755 (rwxr-xr-x).
• O 2 é o bit de escrita: retira-a ao grupo e aos outros; o dono não perde nada.

$ touch notas.txt; mkdir docs
$ ls -l
total 4
drwxr-xr-x 2 aluno aluno 4096 Oct 24 10:15 docs
-rw-r--r-- 1 aluno aluno    0 Oct 24 10:15 notas.txt

A prova: umask 033

Diz-se muitas vezes que a máscara «se subtrai» de 666. Com os valores habituais a conta bate certo, mas é coincidência. Experimente uma máscara com bits de execução:

$ umask 033
$ touch teste.txt; ls -l teste.txt
-rw-r--r-- 1 aluno aluno 0 Oct 24 10:16 teste.txt

Se fosse subtração, 666 − 033 daria 633 (rw--wx-wx), um resultado absurdo. O ficheiro nasce 644 porque o 3 (escrita + execução) só desliga bits: a escrita do grupo e dos outros desaparece, e a execução, que nunca esteve ligada, não muda nada.

umask 077: ficheiros privados

No outro extremo está 077, muito usado em servidores: retira todas as permissões ao grupo e aos outros. Os ficheiros novos ficam em 600 e os diretórios em 700 — mais ninguém pode sequer ler.

$ umask 077
$ touch privado.txt; mkdir cofre
$ ls -ld privado.txt cofre
drwx------ 2 aluno aluno 4096 Oct 24 10:17 cofre
-rw------- 1 aluno aluno    0 Oct 24 10:17 privado.txt

Que máscara escolher

• 022 — 644 / 755. Todos leem, só o dono escreve. Aceitável num portátil pessoal.
• 027 — 640 / 750. O grupo lê, os outros não veem nada. Bom compromisso em servidores com equipas.
• 077 — 600 / 700. Privado. Recomendado em máquinas partilhadas e para dados sensíveis.
• 002 — 664 / 775. O grupo também escreve. Útil em diretórios de projeto de uma equipa; nunca para dados sensíveis.

A diferença entre 022 e 077 é a diferença entre partilhar e proteger. E a máscara só atua na criação: os ficheiros que já existiam ficam como estavam.

Modo simbólico

Tal como o chmod, o umask aceita notação simbólica, que muitos acham mais clara do que os números invertidos. Repare: aqui escreve-se o que se quer permitir, não o que se quer retirar.

$ umask u=rwx,g=rx,o=
$ umask
0027
$ umask u=rwx,g=,o=
$ umask
0077

No primeiro caso, o dono fica com tudo, o grupo com leitura e execução e os outros com nada; o bash traduz para 0027 — ficheiros 640, partilháveis na equipa mas não com a máquina inteira. Com g= e o= vazios obtém-se 077. Também há operadores relativos: umask g-w retira a escrita ao grupo e umask o-rwx fecha tudo aos outros.

Tornar a máscara persistente

Há um pormenor crítico: o umask escrito na consola só dura naquela sessão. Ao sair e voltar a entrar, regressa ao predefinido. Para que a escolha fique, a linha tem de estar num ficheiro lido no arranque.

Para a sua conta: ~/.bashrc

$ echo 'umask 077' >> ~/.bashrc
$ tail -n 1 ~/.bashrc
umask 077

A sessão atual não muda (source ~/.bashrc aplica já); as seguintes começam com a máscara escolhida.

Para todo o sistema: /etc/profile e /etc/login.defs

• /etc/profile — lido pelas shells de login de todos os utilizadores; mais arrumado é um script em /etc/profile.d/. O ~/.bashrc de cada um é lido depois e prevalece.
• /etc/login.defs — o UMASK é aplicado pelo pam_umask a todas as sessões (consola, SSH, ambiente gráfico), antes de qualquer shell, e o useradd também o consulta. É o sítio certo para a política da máquina.

$ echo 'umask 027' | sudo tee /etc/profile.d/umask.sh
umask 027
$ grep '^UMASK' /etc/login.defs
UMASK           022

Para serviços: UMask= no systemd

Os serviços não leem o ~/.bashrc nem o /etc/profile: a máscara vem da diretiva UMask= da unit, que por omissão é 0022. Para a mudar, crie um override e reinicie o serviço:

$ systemctl show -p UMask relatorios.service
UMask=0022
$ sudo systemctl edit relatorios.service
# no editor:
[Service]
UMask=0027
$ sudo systemctl restart relatorios.service

A máscara efetiva de um processo em execução aparece na linha Umask: de /proc/PID/status. E, para um único comando, use uma subshell: (umask 077; tar czf copia.tar.gz dados/).

umask em cibersegurança

Ficheiros sensíveis legíveis por todos. Com 022, cada cópia de base de dados, exportação em CSV ou configuração com palavras-passe nasce legível por qualquer conta local. Quem obtém uma conta de baixo privilégio — a do servidor web, por exemplo — começa precisamente por procurar ficheiros assim. Uma auditoria rápida: find /srv /var/backups -type f -perm -o=r.

Serviços com uma máscara demasiado aberta. Os daemons herdam UMask=0022 do systemd e alguns chegam a chamar umask(0). Reveja os serviços que gravam dados (systemctl show -p UMask), defina 0027 ou 0077 nos que tratam informação sensível e corrija com chmod o que já foi criado.

Na resposta a incidentes. Uma linha umask 000 acrescentada a um ficheiro de arranque ou a uma unit é um indicador a investigar: torna tudo o que for criado gravável por qualquer conta. E ao recolher evidências, comece por umask 077, para que o próprio material recolhido não fique exposto na máquina comprometida.

Experimente no simulador interativo

O simulador recria uma máquina de laboratório com a máscara 0022. No painel esquerdo vê a conta bit a bit — máscara, bases 666 e 777 e resultado —, os ficheiros de ~/lab e onde a máscara está definida; à direita, o terminal. Experimente umask 033, compare 027, 077 e 002, saia da sessão para ver o que se perde e corrija um serviço que grava dados de clientes legíveis por todos. Demonstrar tudo segue a sequência guiada; Anterior e Seguinte avançam passo a passo; Repor estado volta ao início.

Erros comuns e boas práticas

• Tratar o umask como subtração: funciona por acaso com 022, falha com 033 ou 027. Pense em bits desligados.
• Esperar que altere ficheiros existentes: só atua na criação. Para o que já existe, use chmod, chown ou chgrp.
• Definir a máscara só na consola: perde-se ao fechar a sessão. Use o ~/.bashrc, o /etc/profile.d/ ou o /etc/login.defs.
• Esquecer os serviços: o systemd ignora os ficheiros da shell; a máscara define-se com UMask= na unit.
• Contar com o umask para dar permissões: só retira. Um programa que pede 600 fica em 600 com qualquer máscara — por isso o ssh-keygen protege as chaves privadas mesmo com 022.
• Usar dígitos fora do octal: umask 088 dá erro e a máscara fica como estava. Confirme sempre com umask -S.

---

Conclusão

O umask é o par invisível do chmod: decide as permissões no momento em que cada ficheiro nasce. Sozinho mostra a máscara, o -S mostra-a em símbolos, 022 é o predefinido partilhável, 077 o privado, e a linha no ficheiro de arranque — ou o UMask= do serviço — torna a escolha permanente. Para corrigir o que já existe, veja o artigo sobre o comando chmod; para mudar dono e grupo, o artigo sobre o chown e chgrp.

Este artigo faz parte da série «Comandos Linux, um a um» do blog HJFR — fique atento aos próximos comandos.