Modificação de Permissões no Linux

Introdução

As permissões de arquivos no Linux são um recurso fundamental de segurança que controla como arquivos e diretórios podem ser acessados, modificados e executados por diferentes usuários. Compreender e gerenciar efetivamente essas permissões é essencial para manter a segurança do sistema e o compartilhamento adequado de recursos.

Neste laboratório, você aprenderá como visualizar, definir e modificar as permissões de arquivos usando o comando chmod. O comando chmod permite que os administradores controlem quem pode ler, escrever ou executar arquivos específicos, garantindo que dados sensíveis permaneçam protegidos, enquanto os recursos necessários permanecem acessíveis aos usuários autorizados.

Ao final deste laboratório, você será capaz de criar arquivos com permissões específicas, modificar as permissões de arquivos existentes e atribuir controles de acesso baseados em grupos - habilidades cruciais para qualquer administrador ou usuário de sistema Linux.

Entendendo as Permissões de Arquivos no Linux

O Linux implementa um sistema de permissões que permite um controle preciso sobre quem pode acessar arquivos e diretórios e quais ações eles podem realizar. Nesta etapa, você aprenderá como as permissões do Linux funcionam e como visualizá-las.

Primeiro, navegue até o diretório de trabalho onde você realizará todas as operações para este laboratório:

cd ~/project

Vamos criar um arquivo de exemplo para examinar suas permissões:

touch sample_file.txt

Para visualizar as permissões deste arquivo, use o comando ls com a opção -l:

ls -l sample_file.txt

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

-rw-rw-r-- 1 labex labex 0 Oct 25 12:34 sample_file.txt

Vamos analisar essa saída:

1. O primeiro caractere (-) indica o tipo de arquivo. Um traço (-) representa um arquivo regular, enquanto d indicaria um diretório.

2. Os nove caracteres seguintes representam as permissões do arquivo em três grupos de três:

   • Os três primeiros caracteres (rw-) mostram as permissões do proprietário
   • Os três seguintes (rw-) mostram as permissões do grupo
   • Os três últimos (r--) mostram as permissões para todos os outros usuários

3. Em cada grupo, as três posições representam:

   • r para permissão de leitura (read)
   • w para permissão de escrita (write)
   • x para permissão de execução (execute)
   • - indica que a permissão não foi concedida

4. Após as permissões, vêm outros detalhes, como o número de links, o nome do proprietário, o nome do grupo, o tamanho do arquivo, a data/hora da última modificação e o nome do arquivo.

Os bits de permissão do Linux também podem ser representados numericamente:

• Leitura (r) = 4
• Escrita (w) = 2
• Execução (x) = 1

Ao somar esses valores, você pode representar qualquer combinação de permissões como um único dígito:

• rwx = 4+2+1 = 7
• rw- = 4+2+0 = 6
• r-x = 4+0+1 = 5
• r-- = 4+0+0 = 4

Isso se torna importante quando usamos o comando chmod com o modo numérico nas etapas posteriores.

Criando Arquivos com Permissões Específicas

Nesta etapa, você criará um novo arquivo e definirá suas permissões iniciais para restringir o acesso apenas ao proprietário. Isso é útil ao criar arquivos que contêm informações confidenciais que não devem ser acessíveis a outros usuários.

Primeiro, crie um novo arquivo chamado secure_file.txt:

touch secure_file.txt

Agora, vamos adicionar algum conteúdo ao arquivo:

echo "This file contains secure information." > secure_file.txt

Por padrão, a maioria dos sistemas Linux cria arquivos com permissões que permitem que o proprietário e o grupo leiam e escrevam, enquanto outros só podem ler. Vamos verificar as permissões atuais:

ls -l secure_file.txt

Você deve ver uma saída semelhante a:

-rw-rw-r-- 1 labex labex 37 Oct 25 12:40 secure_file.txt

Para um arquivo contendo informações confidenciais, queremos restringir o acesso apenas ao proprietário. Usaremos o comando chmod com o modo numérico para definir as permissões para 600, o que significa:

• Proprietário: Leitura e Escrita (6 = 4+2)
• Grupo: Sem permissões (0)
• Outros: Sem permissões (0)

Execute o seguinte comando para alterar as permissões:

chmod 600 secure_file.txt

Agora verifique as permissões novamente:

ls -l secure_file.txt

A saída agora deve mostrar:

-rw------- 1 labex labex 37 Oct 25 12:40 secure_file.txt

Observe como as permissões foram alteradas - agora apenas o proprietário (usuário labex) tem permissões de leitura e escrita, enquanto os membros do grupo e outros usuários não têm acesso a este arquivo.

Vamos tentar criar outro arquivo, mas desta vez definiremos as permissões no momento da criação usando uma técnica diferente.

Primeiro, crie um novo arquivo chamado public_file.txt com conteúdo:

echo "This file is readable by everyone." > public_file.txt

Agora, vamos tornar este arquivo legível por todos, mas apenas gravável pelo proprietário:

chmod 644 public_file.txt

Verifique as permissões:

ls -l public_file.txt

Você deve ver:

-rw-r--r-- 1 labex labex 33 Oct 25 12:45 public_file.txt

Este conjunto de permissões (644) é comumente usado para arquivos públicos que todos devem ser capazes de ler, mas apenas o proprietário pode modificar.

Usando o Modo Simbólico com chmod

Na etapa anterior, você usou o modo numérico para definir permissões. Agora, vamos explorar o modo simbólico, que fornece uma maneira mais intuitiva de modificar as permissões.

O modo simbólico usa letras e símbolos para representar usuários e permissões:

• u - Usuário (proprietário)
• g - Grupo
• o - Outros (todos os outros)
• a - Todos (equivalente a ugo)

E os símbolos de permissão:

• r - Leitura (Read)
• w - Escrita (Write)
• x - Execução (Execute)

Vamos criar um arquivo de script para praticar:

touch my_script.sh

Adicione um comando simples ao script:

echo '#!/bin/bash' > my_script.sh
echo 'echo "Hello from the script!"' >> my_script.sh

Verifique as permissões atuais:

ls -l my_script.sh

Você deve ver que o script não é executável:

-rw-rw-r-- 1 labex labex 44 Oct 25 12:50 my_script.sh

Para tornar o script executável para o proprietário, use:

chmod u+x my_script.sh

Isso adiciona (+) a permissão de execução (x) para o usuário/proprietário (u).

Verifique as permissões novamente:

ls -l my_script.sh

Você deve ver agora:

-rwxrw-r-- 1 labex labex 44 Oct 25 12:50 my_script.sh

Agora, vamos torná-lo executável para todos:

chmod a+x my_script.sh

Isso adiciona a permissão de execução para todos os usuários (proprietário, grupo e outros).

Verifique as permissões novamente:

ls -l my_script.sh

Você deve ver:

-rwxrwxr-x 1 labex labex 44 Oct 25 12:50 my_script.sh

Vamos executar o script:

./my_script.sh

Você deve ver:

Hello from the script!

Você também pode remover permissões usando o operador -. Por exemplo, para remover a permissão de escrita para o grupo e outros:

chmod go-w my_script.sh

Verifique as permissões:

ls -l my_script.sh

Você deve ver:

-rwxr-xr-x 1 labex labex 44 Oct 25 12:50 my_script.sh

Você também pode definir várias permissões de uma vez. Por exemplo, para dar permissões de leitura e execução a todos, mas permissão de escrita apenas ao proprietário:

chmod u=rwx,go=rx my_script.sh

Isso define (=) as permissões específicas para cada categoria.

Verifique as permissões mais uma vez:

ls -l my_script.sh

O resultado deve ser o mesmo de antes:

-rwxr-xr-x 1 labex labex 44 Oct 25 12:50 my_script.sh

Trabalhando com Permissões de Grupo

O Linux permite que arquivos sejam associados a grupos, permitindo o controle de acesso colaborativo. Nesta etapa, você aprenderá como criar um grupo, alterar a propriedade do grupo de um arquivo e definir as permissões de grupo apropriadas.

Primeiro, vamos criar um novo grupo. Em um cenário do mundo real, isso pode representar um departamento ou equipe de projeto:

sudo groupadd developers

Agora, vamos criar um arquivo que será compartilhado com este grupo:

touch shared_config.txt
echo "## Development configuration settings" > shared_config.txt
echo "debug_mode=true" >> shared_config.txt
echo "log_level=verbose" >> shared_config.txt

Atualmente, este arquivo pertence ao seu usuário e ao seu grupo principal. Vamos verificar:

ls -l shared_config.txt

Você deve ver uma saída semelhante a:

-rw-rw-r-- 1 labex labex 61 Oct 25 13:00 shared_config.txt

Para alterar a propriedade do grupo do arquivo para o grupo developers, use o comando chown:

sudo chown labex:developers shared_config.txt

A sintaxe é chown usuário:grupo nome_do_arquivo. Aqui, estamos mantendo o usuário como labex, mas alterando o grupo para developers.

Verifique a propriedade agora:

ls -l shared_config.txt

Você deve ver:

-rw-rw-r-- 1 labex developers 61 Oct 25 13:00 shared_config.txt

Observe que o grupo foi alterado para developers, mas as permissões ainda são as mesmas. Vamos modificá-las para permitir que os membros do grupo leiam, mas não escrevam, enquanto impedimos o acesso de outros:

chmod 640 shared_config.txt

Isso define:

• Proprietário: Leitura e escrita (6 = 4+2)
• Grupo: Somente leitura (4)
• Outros: Sem permissões (0)

Verifique as permissões novamente:

ls -l shared_config.txt

Você deve ver agora:

-rw-r----- 1 labex developers 61 Oct 25 13:00 shared_config.txt

Agora, os membros do grupo developers podem ler este arquivo de configuração, mas não podem modificá-lo. Os usuários que não estão no grupo developers não podem acessar o arquivo.

Você também pode usar o modo simbólico para obter o mesmo resultado:

chmod u=rw,g=r,o= shared_config.txt

Este comando define explicitamente:

• Usuário/proprietário: Leitura e escrita
• Grupo: Somente leitura
• Outros: Sem permissões

Para adicionar um usuário ao grupo developers, você normalmente usaria:

sudo usermod -a -G developers username

No entanto, isso está além do escopo deste laboratório específico, pois exigiria a criação de contas de usuário adicionais.

Resumo

Neste laboratório, você aprendeu os conceitos e práticas essenciais das permissões de arquivos no Linux. Aqui está um resumo do que você realizou:

1. Você adquiriu uma compreensão de como os modelos de permissão do Linux funcionam, incluindo os conceitos de permissões de leitura, escrita e execução para usuários, grupos e outros.

2. Você criou arquivos com permissões específicas, aprendendo a usar o comando chmod com o modo numérico para definir níveis de acesso apropriados para diferentes tipos de arquivos.

3. Você explorou o modo simbólico do comando chmod, que fornece uma abordagem mais intuitiva para adicionar, remover ou definir permissões específicas.

4. Você trabalhou com permissões de grupo, aprendendo como criar grupos, alterar a propriedade do grupo de arquivos e definir controles de acesso apropriados no nível do grupo.

Essas habilidades são fundamentais para manter a segurança e controlar o acesso em sistemas Linux. Seja gerenciando configurações de servidor, desenvolvendo software ou simplesmente organizando seus arquivos pessoais, entender como definir e modificar corretamente as permissões de arquivos é uma habilidade essencial para qualquer usuário Linux.

Ao continuar trabalhando com o Linux, lembre-se de que o gerenciamento adequado de permissões é um componente-chave da segurança do sistema. Sempre siga o princípio do menor privilégio - conceda aos usuários e processos apenas as permissões de que precisam para realizar suas tarefas, e nada mais.