Controlar Acesso a Arquivos no Red Hat Enterprise Linux

Introdução

Neste laboratório, você obterá uma compreensão abrangente da gestão de permissões do sistema de arquivos Linux, uma habilidade crucial para qualquer administrador do RHEL. Você aprenderá a interpretar permissões de arquivos usando ls -l, modificá-las com chmod nos modos simbólico e octal, e alterar a propriedade de arquivos usando chown. Além disso, explorará e aplicará permissões especiais como SUID, SGID e o Sticky Bit, e configurará permissões padrão eficazmente com umask. Esta experiência prática equipará você com o conhecimento necessário para proteger e controlar o acesso a arquivos e diretórios em um ambiente Linux.

Interpretar Permissões do Sistema de Arquivos Linux com ls -l

Neste passo, você aprenderá a interpretar as permissões do sistema de arquivos Linux usando o comando ls -l. Compreender as permissões de arquivos é crucial para gerenciar o acesso a arquivos e diretórios em um ambiente Linux.

Cada arquivo e diretório no Linux possui permissões associadas que determinam quem pode lê-los, escrevê-los ou executá-los. Essas permissões são divididas em três categorias:

Usuário (proprietário): As permissões para o proprietário do arquivo.
Grupo: As permissões para usuários que são membros do grupo do arquivo.
Outros: As permissões para todos os outros usuários no sistema.

Cada categoria pode ter três tipos de permissões:

Leitura (r): Permite visualizar o conteúdo de um arquivo ou listar o conteúdo de um diretório.
Escrita (w): Permite modificar o conteúdo de um arquivo ou criar/excluir arquivos dentro de um diretório.
Execução (x): Permite executar um arquivo executável ou entrar em um diretório.

Vamos começar criando um novo diretório e um arquivo dentro do diretório ~/project para observar suas permissões padrão.

Primeiro, crie um diretório chamado my_files:

mkdir ~/project/my_files

Em seguida, crie um arquivo vazio chamado document.txt dentro do diretório my_files:

touch ~/project/my_files/document.txt

Agora, use o comando ls -l para visualizar as permissões detalhadas do arquivo document.txt. O comando ls -l fornece uma lista longa, incluindo permissões de arquivo, proprietário, grupo, tamanho e data de modificação.

ls -l ~/project/my_files/document.txt

Você deve ver uma saída semelhante a esta:

-rw-rw-r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Vamos analisar a primeira parte da saída, -rw-rw-r--.:

O primeiro caractere (-) indica o tipo de arquivo.
- - significa que é um arquivo regular.
- d significa que é um diretório.
- l significa que é um link simbólico.
Os próximos nove caracteres são divididos em três conjuntos de três:
- rw-: Permissões para o proprietário (labex). r (leitura), w (escrita), - (sem execução).
- rw-: Permissões para o grupo (labex). r (leitura), w (escrita), - (sem execução).
- r--: Permissões para outros. r (leitura), - (sem escrita), - (sem execução).

Isso significa que o usuário labex (proprietário) e os usuários no grupo labex podem ler e escrever em document.txt, enquanto todos os outros usuários só podem lê-lo.

Agora, vamos examinar as permissões do próprio diretório my_files. Ao usar ls -l em um diretório, ele lista o conteúdo do diretório. Para visualizar as permissões do próprio diretório, você precisa usar a opção -d com ls -l.

ls -ld ~/project/my_files

Você deve ver uma saída semelhante a esta:

drwxrwxr-x 2 labex labex 4096 Jun  6 17:36 /home/labex/project/my_files

Vamos interpretar as permissões drwxrwxr-x.:

O primeiro caractere (d) indica que é um diretório.
rwx: Permissões para o proprietário (labex). r (leitura), w (escrita), x (execução).
rwx: Permissões para o grupo (labex). r (leitura), w (escrita), x (execução).
r-x: Permissões para outros. r (leitura), - (sem escrita), x (execução).

Para diretórios:

r (leitura) permite listar o conteúdo do diretório.
w (escrita) permite criar, excluir ou renomear arquivos dentro do diretório.
x (execução) permite entrar no diretório (usando cd) e acessar seus arquivos e subdiretórios.

Isso significa que o usuário labex e os usuários no grupo labex podem listar, criar/excluir arquivos e entrar no diretório my_files. Outros usuários podem listar e entrar no diretório, mas não podem criar ou excluir arquivos dentro dele.

Alterar Permissões de Arquivos com chmod (Modo Simbólico)

Neste passo, você aprenderá a alterar permissões de arquivos usando o comando chmod no modo simbólico. O modo simbólico utiliza letras e símbolos para representar as alterações de permissões, tornando intuitivo adicionar, remover ou definir permissões específicas.

O comando chmod no modo simbólico segue a sintaxe: chmod QUEM OPERAÇÃO PERMISSÕES ARQUIVO.

QUEM: Especifica a quem a alteração de permissão se aplica.
- u: usuário (proprietário)
- g: grupo
- o: outros
- a: todos (usuário, grupo e outros)
OPERAÇÃO: Especifica como modificar as permissões.
- +: Adicionar uma permissão.
- -: Remover uma permissão.
- =: Definir as permissões exatamente como especificadas, substituindo as existentes.
PERMISSÕES: Especifica o tipo de permissão.
- r: leitura
- w: escrita
- x: execução

Vamos continuar trabalhando com o arquivo ~/project/my_files/document.txt e o diretório ~/project/my_files criados no passo anterior.

Primeiro, vamos remover a permissão de escrita para o grupo e outros do arquivo document.txt. Lembre-se que as permissões atuais são -rw-rw-r--.

chmod go-w ~/project/my_files/document.txt

Agora, verifique a alteração usando ls -l:

ls -l ~/project/my_files/document.txt

A saída agora deve mostrar:

-rw-r--r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Observe que a permissão w (escrita) para o grupo e outros foi removida.

Em seguida, vamos adicionar a permissão de execução para o proprietário (u) em document.txt. Isso geralmente é feito para scripts torná-los executáveis.

chmod u+x ~/project/my_files/document.txt

Verifique a alteração:

ls -l ~/project/my_files/document.txt

A saída agora deve ser:

-rwxr--r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

O proprietário agora tem permissão de execução (x).

Agora, vamos praticar com o diretório ~/project/my_files. Suas permissões atuais são drwxrwxr-x. Vamos remover a permissão de escrita para outros (o) do diretório.

chmod o-w ~/project/my_files

Verifique a alteração:

ls -ld ~/project/my_files

A saída agora deve mostrar:

drwxr-xr-x 2 labex labex 4096 Jun  6 17:36 /home/labex/project/my_files

Espere, por que o-w não alterou a saída? Isso ocorre porque os outros (o) já não tinham permissão de escrita. O r-x para outros significa leitura e execução, mas sem escrita. Isso demonstra que chmod apenas aplica alterações se forem diferentes do estado atual.

Vamos tentar definir as permissões exatamente. Vamos definir as permissões de document.txt para rw-r--r-- para todos (proprietário, grupo, outros). Isso significa que o proprietário recebe leitura/escrita, o grupo recebe leitura e os outros recebem leitura.

chmod a=rw,g=r,o=r ~/project/my_files/document.txt

Verifique a alteração:

ls -l ~/project/my_files/document.txt

A saída agora deve ser:

-rw-r--r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Este comando a=rw,g=r,o=r é um pouco redundante, pois a=rw aplicaria rw a todos, então g=r definiria o grupo para r (substituindo o w de a=rw), e o=r definiria outros para r (substituindo o w de a=rw). Uma maneira mais simples de alcançar rw-r--r-- seria chmod u=rw,go=r. Vamos tentar isso.

chmod u=rw,go=r ~/project/my_files/document.txt

Verifique a alteração:

ls -l ~/project/my_files/document.txt

A saída ainda deve ser:

-rw-r--r-- 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Finalmente, vamos tornar document.txt executável para todos.

chmod a+x ~/project/my_files/document.txt

Verifique a alteração:

ls -l ~/project/my_files/document.txt

A saída agora deve ser:

-rwxr-xr-x 1 labex labex 0 Jun  6 17:36 /home/labex/project/my_files/document.txt

Alterar Permissões de Arquivos com chmod (Modo Octal)

Neste passo, você aprenderá a alterar permissões de arquivos usando o comando chmod no modo octal (numérico). O modo octal é uma forma concisa de representar permissões, onde cada permissão (leitura, escrita, execução) é atribuída um valor numérico.

Os valores numéricos para as permissões são:

Leitura (r): 4
Escrita (w): 2
Execução (x): 1
Sem permissão (-): 0

Para determinar o valor octal para um conjunto de permissões (usuário, grupo ou outros), você soma os valores das permissões concedidas.

Por exemplo:

rwx (leitura, escrita, execução) = 4 + 2 + 1 = 7
rw- (leitura, escrita, sem execução) = 4 + 2 + 0 = 6
r-x (leitura, sem escrita, execução) = 4 + 0 + 1 = 5
r-- (leitura, sem escrita, sem execução) = 4 + 0 + 0 = 4
--- (sem permissões) = 0 + 0 + 0 = 0

O comando chmod no modo octal usa um número de três dígitos, onde cada dígito representa as permissões para o proprietário, grupo e outros, respectivamente. A sintaxe é: chmod OGO ARQUIVO.

O: Valor octal para as permissões do proprietário.
G: Valor octal para as permissões do grupo.
O: Valor octal para as permissões dos outros.

Vamos continuar trabalhando com ~/project/my_files/document.txt e ~/project/my_files.

Primeiro, vamos definir as permissões de document.txt para rw-r--r--.

Proprietário: rw- = 6
Grupo: r-- = 4
Outros: r-- = 4

Portanto, o valor octal será 644.

chmod 644 ~/project/my_files/document.txt

Verifique a alteração:

ls -l ~/project/my_files/document.txt

A saída agora deve ser:

-rw-r--r-- 1 labex labex 0 Jun  6 00:48 /home/labex/project/my_files/document.txt

Em seguida, vamos tornar document.txt executável apenas pelo proprietário, mantendo leitura/escrita para o proprietário e apenas leitura para o grupo e outros. Isso significa que o proprietário terá rwx (7), o grupo r-- (4) e os outros r-- (4). O valor octal será 744.

chmod 744 ~/project/my_files/document.txt

Verifique a alteração:

ls -l ~/project/my_files/document.txt

A saída agora deve ser:

-rwxr--r-- 1 labex labex 0 Jun  6 00:48 /home/labex/project/my_files/document.txt

Agora, vamos alterar as permissões do diretório ~/project/my_files. Suas permissões atuais são drwxr-xr-x. Vamos definir suas permissões para rwxr-x---.

Proprietário: rwx = 7
Grupo: r-x = 5
Outros: --- = 0

Portanto, o valor octal será 750.

chmod 750 ~/project/my_files

Verifique a alteração:

ls -ld ~/project/my_files

A saída agora deve mostrar:

drwxr-x--- 2 labex labex 26 Jun  6 00:48 /home/labex/project/my_files

Isso significa que o proprietário (labex) tem permissões completas (leitura, escrita, execução), o grupo (labex) pode ler e executar (entrar) no diretório, e outros não têm permissões.

Finalmente, vamos criar um novo arquivo de script executável para demonstrar a definição de permissões de execução diretamente.

echo '#!/bin/bash' > ~/project/my_script.sh
echo 'echo "Hello from my script!"' >> ~/project/my_script.sh

Por padrão, novos arquivos não são executáveis. Vamos verificar suas permissões:

ls -l ~/project/my_script.sh

Provavelmente você verá permissões como -rw-r--r--. Para torná-lo executável para o proprietário e grupo, mas não para outros, queremos rwxrwx---.

Proprietário: rwx = 7
Grupo: rwx = 7
Outros: --- = 0

Portanto, o valor octal será 770.

chmod 770 ~/project/my_script.sh

Verifique a alteração:

ls -l ~/project/my_script.sh

A saída agora deve ser:

-rwxrwx--- 1 labex labex 41 Jun  6 00:52 /home/labex/project/my_script.sh

Agora você pode executar o script:

~/project/my_script.sh

Você deve ver a saída:

Hello from my script!

Alterar Propriedade de Arquivo com chown

Neste passo, você aprenderá a alterar o proprietário e o grupo de arquivos e diretórios usando o comando chown. Esta é uma tarefa administrativa crucial, pois apenas o usuário root pode alterar o proprietário de um arquivo. O usuário labex possui privilégios sudo, o que permitirá executar essas ações.

A sintaxe básica para chown é: chown [OPÇÕES] NOVO_PROPRIETÁRIO[:NOVO_GRUPO] ARQUIVO(s).

Começaremos criando um novo usuário e grupo que podemos usar para demonstrar as mudanças de propriedade. Como este ambiente é baseado em contêiner, criaremos um usuário e grupo simples para fins de demonstração.

Primeiro, crie um novo grupo chamado devs:

sudo groupadd devs

Em seguida, crie um novo usuário chamado developer e adicione-o ao grupo devs. Criaremos um usuário do sistema sem diretório inicial ou shell de login para esta demonstração.

sudo useradd -r -g devs -s /sbin/nologin developer

Agora, vamos alterar o proprietário de ~/project/my_files/document.txt de labex para developer.

sudo chown developer ~/project/my_files/document.txt

Verifique a alteração usando ls -l:

ls -l ~/project/my_files/document.txt

A saída agora deve mostrar developer como o proprietário:

-rwxr--r-- 1 developer labex 0 Jun  6 00:48 /home/labex/project/my_files/document.txt

Observe que a propriedade do grupo (labex) permaneceu inalterada.

Você também pode alterar simultaneamente o proprietário e o grupo usando a sintaxe proprietário:grupo. Vamos alterar o proprietário de document.txt de volta para labex e seu grupo para devs.

sudo chown labex:devs ~/project/my_files/document.txt

Verifique a alteração:

ls -l ~/project/my_files/document.txt

A saída agora deve mostrar labex como o proprietário e devs como o grupo:

-rwxr--r-- 1 labex devs 0 Jun  6 00:48 /home/labex/project/my_files/document.txt

O comando chown também suporta a opção -R (recursivo), que permite alterar a propriedade de toda uma árvore de diretórios. Vamos alterar o proprietário do diretório ~/project/my_files e todos os seus conteúdos para developer, e o grupo para devs.

sudo chown -R developer:devs ~/project/my_files

Verifique a alteração para o diretório:

ls -ld ~/project/my_files

A saída deve refletir a nova propriedade:

drwxr-x--- 2 developer devs 26 Jun  6 00:48 /home/labex/project/my_files

Observe que, após alterar a propriedade do diretório para developer:devs, o usuário labex não poderá mais acessar o arquivo dentro do diretório porque as permissões do diretório são drwxr-x--- (o proprietário e o grupo têm acesso, mas outros não), e labex não é nem o proprietário (developer) nem membro do grupo (devs). Se você tentar listar o arquivo agora:

ls -l ~/project/my_files/document.txt

Você receberá um erro "Permissão negada". Isso demonstra como a propriedade e as permissões funcionam juntas para controlar o acesso.

Você também pode alterar apenas a propriedade do grupo usando chown :NOVO_GRUPO ARQUIVO(s). Isso é equivalente ao uso do comando chgrp. Vamos alterar o grupo de ~/project/my_script.sh para devs.

sudo chown :devs ~/project/my_script.sh

Verifique a alteração:

ls -l ~/project/my_script.sh

A saída deve mostrar devs como o proprietário do grupo, enquanto labex permanece como o proprietário do arquivo:

-rwxrwx--- 1 labex devs 41 Jun  6 00:52 /home/labex/project/my_script.sh

Finalmente, vamos limpar, alterando a propriedade de volta para labex:labex e, em seguida, removendo o usuário developer e o grupo devs.

sudo chown -R labex:labex ~/project/my_files
sudo userdel developer
sudo groupdel devs

Compreender e Aplicar Permissões Especiais (SUID, SGID, Bit Sticky)

Neste passo, você explorará as permissões especiais no Linux: SUID (Set User ID), SGID (Set Group ID) e o Sticky Bit. Essas permissões fornecem um controle aprimorado sobre a execução de arquivos e o comportamento de diretórios.

As permissões especiais são representadas por um dígito adicional no modo de permissão octal, colocado antes dos três dígitos padrão (proprietário, grupo, outros).

SUID (Set User ID):
- Valor octal: 4
- Efeito em arquivos: Quando um arquivo executável com SUID é executado, ele é executado com as permissões do proprietário do arquivo, não do usuário que o executou. Isso é comumente usado para programas que precisam de privilégios elevados para realizar certas tarefas, como o comando passwd (que precisa escrever em /etc/shadow, um arquivo de propriedade do root).
- Na saída de ls -l: Um s aparece no lugar da permissão x (executar) do proprietário. Se o proprietário não tiver permissão de execução, um S maiúsculo aparece.
SGID (Set Group ID):
- Valor octal: 2
- Efeito em arquivos: Semelhante ao SUID, mas o executável é executado com as permissões do proprietário do grupo do arquivo.
- Efeito em diretórios: Arquivos e subdiretórios criados dentro de um diretório habilitado para SGID herdam a propriedade do grupo desse diretório, em vez do grupo primário do usuário que os criou. Isso é muito útil para diretórios compartilhados onde todos os arquivos devem pertencer a um grupo específico.
- Na saída de ls -l: Um s aparece no lugar da permissão x (executar) do grupo. Se o grupo não tiver permissão de execução, um S maiúsculo aparece.
Sticky Bit:
- Valor octal: 1
- Efeito em arquivos: Nenhum efeito.
- Efeito em diretórios: Os usuários podem criar arquivos no diretório, mas só podem excluir ou renomear arquivos que possuem. Isso impede que os usuários excluam ou movam arquivos de outros usuários em um diretório compartilhado (por exemplo, /tmp).
- Na saída de ls -l: Um t aparece no lugar da permissão x (executar) de outros. Se outros não tiverem permissão de execução, um T maiúsculo aparece.

Vamos demonstrar essas permissões especiais.

Exemplo SUID

Criaremos um programa C simples que tenta ler um arquivo restrito.

Primeiro, crie um arquivo que apenas o root pode ler:

sudo touch ~/project/secret_data.txt
sudo chmod 600 ~/project/secret_data.txt
sudo chown root:root ~/project/secret_data.txt

Verifique suas permissões:

ls -l ~/project/secret_data.txt

Saída:

-rw------- 1 root root 0 Jun  6 17:36 /home/labex/project/secret_data.txt

Agora, crie um programa C read_secret.c que tenta ler este arquivo:

nano ~/project/read_secret.c

Cole o seguinte código em read_secret.c:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    FILE *fp;
    char buffer[256];

    printf("Attempting to read /home/labex/project/secret_data.txt...\n");

    fp = fopen("/home/labex/project/secret_data.txt", "r");
    if (fp == NULL) {
        perror("Error opening file");
        return 1;
    }

    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("%s", buffer);
    }

    fclose(fp);
    printf("Successfully read file.\n");
    return 0;
}

Salve e saia do nano (Ctrl+S, Ctrl+X).

Compile o programa:

gcc ~/project/read_secret.c -o ~/project/read_secret

Agora, tente executá-lo como labex:

~/project/read_secret

Você deve ver uma mensagem "Error opening file: Permission denied" (Erro ao abrir o arquivo: Permissão negada), pois labex não tem acesso de leitura a secret_data.txt.

Agora, vamos fazer com que read_secret seja de propriedade do root e definir o bit SUID.

sudo chown root:root ~/project/read_secret
sudo chmod u+s ~/project/read_secret

Verifique as permissões:

ls -l ~/project/read_secret

Saída:

-rwsr-xr-x 1 root root 17704 Jun  6 01:02 /home/labex/project/read_secret

Observe o s no conjunto de permissões do proprietário. Agora, execute o programa novamente como labex:

~/project/read_secret

Desta vez, ele deve ler o arquivo com sucesso (embora esteja vazio, então nenhum conteúdo será impresso, mas a mensagem "Successfully read file." (Arquivo lido com sucesso) indica sucesso). Isso ocorre porque o bit SUID fez com que o programa fosse executado com as permissões do root.

Exemplo SGID (em Diretório)

Vamos criar um diretório compartilhado e um novo grupo.

sudo groupadd shared_group
sudo mkdir ~/project/shared_dir
sudo chown labex:shared_group ~/project/shared_dir
sudo chmod 770 ~/project/shared_dir

Agora, defina o bit SGID em shared_dir:

sudo chmod g+s ~/project/shared_dir

Verifique as permissões:

ls -ld ~/project/shared_dir

Saída:

drwxrws--- 2 labex shared_group 6 Jun  6 01:02 /home/labex/project/shared_dir

Observe o s no conjunto de permissões do grupo.

Agora, crie um arquivo dentro de shared_dir:

touch ~/project/shared_dir/new_file.txt

Verifique a propriedade de new_file.txt:

ls -l ~/project/shared_dir/new_file.txt

Saída:

-rw-r--r-- 1 labex shared_group 0 Jun  6 01:02 /home/labex/project/shared_dir/new_file.txt

Embora o grupo primário de labex seja labex, o new_file.txt herdou a propriedade do grupo shared_group de shared_dir devido ao bit SGID.

Exemplo Sticky Bit

O diretório /tmp é um exemplo clássico de um diretório com o sticky bit definido. Vamos criar um diretório semelhante.

sudo mkdir ~/project/public_upload
sudo chmod 1777 ~/project/public_upload

O 1 em 1777 é o valor octal para o sticky bit. 777 concede permissões completas ao proprietário, grupo e outros.

Verifique as permissões:

ls -ld ~/project/public_upload

Saída:

drwxrwxrwt 2 root root 6 Jun  6 01:02 /home/labex/project/public_upload

Observe o t no conjunto de permissões de outros.

Agora, vamos simular outro usuário criando um arquivo neste diretório. Como só temos o usuário labex, criaremos um arquivo como labex e, em seguida, tentaremos excluí-lo após alterar sua propriedade para root (simulando outro usuário).

Crie um arquivo como labex:

touch ~/project/public_upload/labex_file.txt

Altere sua propriedade para root:

sudo chown root:root ~/project/public_upload/labex_file.txt

Agora, tente excluir labex_file.txt como labex:

rm ~/project/public_upload/labex_file.txt

Você verá um prompt perguntando se deseja remover o arquivo protegido contra gravação e, após confirmar com y, você receberá um erro "Operation not permitted" (Operação não permitida). Isso ocorre porque o sticky bit impede que os usuários excluam arquivos que não possuem dentro desse diretório, embora labex tenha permissão de gravação no diretório public_upload. Somente root ou o proprietário de labex_file.txt (root neste caso) pode excluí-lo.

Para limpar, você precisará de sudo para remover labex_file.txt:

sudo rm ~/project/public_upload/labex_file.txt

Limpeza

Remova os arquivos e diretórios criados e o usuário/grupo:

sudo rm -f ~/project/secret_data.txt ~/project/read_secret.c ~/project/read_secret
sudo rm -rf ~/project/shared_dir ~/project/public_upload
sudo groupdel shared_group

Configurar Permissões Padrão com umask

Nesta etapa final, você aprenderá sobre umask, que controla as permissões padrão atribuídas a arquivos e diretórios recém-criados. O umask (máscara de modo de criação de arquivo do usuário) é uma máscara de bits que remove permissões das permissões máximas possíveis.

As permissões máximas para um novo arquivo são 666 (rw-rw-rw-), significando leitura e escrita para todos. Novos arquivos normalmente não recebem permissões de execução por padrão por razões de segurança. As permissões máximas para um novo diretório são 777 (rwxrwxrwx), significando leitura, escrita e execução para todos.

O valor umask é subtraído dessas permissões máximas para determinar as permissões padrão reais.

Para visualizar seu valor umask atual, basta digitar umask:

umask

Você provavelmente verá 0002 ou 0022. Neste ambiente, é 0022 para o usuário labex.

Um umask de 0022 significa:

O primeiro 0 é para permissões especiais (SUID, SGID, Sticky Bit), que não são afetadas por umask por padrão.
O segundo 0 significa que nenhuma permissão é removida do proprietário.
O terceiro 2 significa que a permissão de escrita (valor 2) é removida do grupo.
O quarto 2 significa que a permissão de escrita (valor 2) é removida de outros.

Vamos calcular as permissões padrão com um umask de 0022:

Para arquivos (máx. 666):
- Proprietário: 6 - 0 = 6 (rw-)
- Grupo: 6 - 2 = 4 (r--)
- Outros: 6 - 2 = 4 (r--)
- Permissões de arquivo resultantes: 644 (rw-r--r--)
Para diretórios (máx. 777):
- Proprietário: 7 - 0 = 7 (rwx)
- Grupo: 7 - 2 = 5 (r-x)
- Outros: 7 - 2 = 5 (r-x)
- Permissões de diretório resultantes: 755 (rwxr-xr-x)

Vamos testar isso. Crie um novo arquivo e diretório:

touch ~/project/new_file_umask.txt
mkdir ~/project/new_dir_umask

Verifique suas permissões:

ls -l ~/project/new_file_umask.txt
ls -ld ~/project/new_dir_umask

Você deve ver permissões como -rw-r--r-- para o arquivo e drwxr-xr-x para o diretório, confirmando o efeito do umask de 0022.

Agora, vamos mudar o umask para 0077. Este umask removerá todas as permissões de grupo e outros.

umask 0077

Verifique se o umask foi alterado:

umask

Saída:

Agora, vamos calcular as permissões padrão com um umask de 0077:

Para arquivos (máx. 666):
- Proprietário: 6 - 0 = 6 (rw-)
- Grupo: 6 - 7 = -1 (efetivamente 0, ---)
- Outros: 6 - 7 = -1 (efetivamente 0, ---)
- Permissões de arquivo resultantes: 600 (rw-------)
Para diretórios (máx. 777):
- Proprietário: 7 - 0 = 7 (rwx)
- Grupo: 7 - 7 = 0 (---)
- Outros: 7 - 7 = 0 (---)
- Permissões de diretório resultantes: 700 (rwx------)

Vamos testar este novo umask. Crie outro novo arquivo e diretório:

touch ~/project/restricted_file.txt
mkdir ~/project/restricted_dir

Verifique suas permissões:

ls -l ~/project/restricted_file.txt
ls -ld ~/project/restricted_dir

Você deve ver permissões como -rw------- para o arquivo e drwx------ para o diretório.

A configuração umask é normalmente configurada em arquivos de inicialização do shell (como ~/.bashrc ou /etc/profile) para aplicar automaticamente quando um usuário faz login. Para este laboratório, a alteração do umask é temporária e se aplica apenas à sessão atual do terminal.

Para reverter o umask para seu padrão para o usuário labex, você pode simplesmente defini-lo de volta para 0022:

umask 0022

Finalmente, limpe os arquivos e diretórios criados nesta etapa:

rm ~/project/new_file_umask.txt ~/project/restricted_file.txt
rmdir ~/project/new_dir_umask ~/project/restricted_dir

Resumo

Neste laboratório, exploramos os aspectos fundamentais da gestão de permissões do sistema de arquivos Linux. Começamos dominando o comando ls -l para interpretar permissões de arquivos e diretórios, compreendendo a importância das categorias de usuário, grupo e outros, e as permissões de leitura, escrita e execução. Este conhecimento fundamental foi então aplicado para modificar permissões usando chmod em modos simbólico e octal, proporcionando flexibilidade na definição de direitos de acesso.

Além disso, aprendemos como alterar a propriedade de arquivos com o comando chown, o que é crucial para atribuir controle administrativo. O laboratório também abordou a compreensão e aplicação de permissões especiais (SUID, SGID e Bit Sticky), que oferecem controle avançado sobre comportamentos de execução e criação de arquivos. Finalmente, exploramos como configurar permissões padrão para arquivos e diretórios recém-criados usando umask, garantindo configurações de permissão consistentes em todo o sistema.