Conceitos Fundamentais de Segurança (Tríade CIA) em Linux

Introdução

Neste laboratório, você ganhará experiência prática com os princípios fundamentais da segurança da informação, conhecidos como Tríade CIA: Confidencialidade, Integridade e Disponibilidade. Trabalhando em um ambiente Linux, você aprenderá habilidades práticas para proteger dados e garantir a confiabilidade do sistema. O laboratório o guiará pela configuração de permissões de arquivo, demonstração de integridade de arquivo com hashes criptográficos e simulação de monitoramento básico de serviços para entender como esses conceitos centrais são aplicados em cenários do mundo real.

Você começará manipulando permissões de arquivo Linux usando o comando chmod para impor confidencialidade e integridade em um arquivo sensível, garantindo que ele seja acessível e modificável apenas por usuários autorizados. Em seguida, você explorará a integridade de arquivo gerando hashes MD5 e SHA256 para criar uma linha de base e, em seguida, verificará se o arquivo permanece inalterado. Finalmente, você simulará um serviço simples e usará comandos básicos de monitoramento para entender o conceito de disponibilidade e como detectar interrupções de serviço.

Configurar Permissões de Arquivo no Linux para Confidencialidade e Integridade

Nesta etapa, você aprenderá a usar permissões fundamentais de arquivo no Linux para impor dois princípios chave da segurança da informação: Confidencialidade e Integridade. A Confidencialidade garante que os dados sejam acessíveis apenas a usuários autorizados, enquanto a Integridade garante que os dados não sejam alterados de maneira não autorizada. Você criará um arquivo, examinará suas permissões padrão e, em seguida, usará o comando chmod para restringir o acesso e impedir modificações. Todas as operações serão realizadas em seu diretório de projeto principal, ~/project.

Agora, dentro do diretório ~/project, crie um arquivo de exemplo que represente dados sensíveis. Usaremos o comando echo para colocar algum texto dentro dele.

echo "Top Secret Details" > confidential_data.txt

Vamos verificar se o arquivo foi criado e visualizar suas permissões padrão usando o comando ls -l, que fornece um formato de listagem longa.

ls -l confidential_data.txt

Você verá uma saída semelhante a esta. A hora e o tamanho exatos podem variar.

-rw-rw-r-- 1 labex labex 19 Jul 21 15:09 confidential_data.txt

Vamos detalhar a string de permissão -rw-rw-r--:

• O primeiro caractere - indica que é um arquivo regular.
• Os próximos três caracteres rw- são as permissões para o proprietário (usuário labex). r significa leitura, w significa escrita.
• Os próximos três rw- são para o grupo (grupo labex). O grupo pode ler e escrever no arquivo.
• Os últimos três r-- são para outros (todos os outros usuários no sistema). Eles também só podem ler o arquivo.

Esta configuração padrão viola a confidencialidade porque qualquer usuário no sistema pode ler nosso arquivo "Top Secret". Vamos corrigir isso alterando as permissões para que apenas o proprietário possa ler e escrever. Usaremos o comando chmod com códigos numéricos (octais): 4 para leitura, 2 para escrita e 1 para execução. Para dar ao proprietário acesso de leitura/escrita (4+2=6) e remover todo o acesso para o grupo (0) e outros (0), usamos o código 600.

chmod 600 confidential_data.txt

Verifique as permissões novamente:

ls -l confidential_data.txt

A saída agora reflete as novas permissões mais seguras, reforçando a confidencialidade.

-rw------- 1 labex labex 19 Jul 21 15:09 confidential_data.txt

Em seguida, vamos proteger a integridade do arquivo tornando-o somente leitura, mesmo para o proprietário. Isso evita modificações acidentais. Definiremos as permissões para 400, o que significa somente leitura para o proprietário, mantendo tanto a confidencialidade quanto a integridade.

chmod 400 confidential_data.txt

Agora, vamos tentar modificar o arquivo adicionando novo texto a ele.

echo "This should not be added." >> confidential_data.txt

A operação falhará e você verá um erro "Permission denied" (Permissão negada). Isso demonstra que a integridade do arquivo está protegida contra alterações.

zsh: permission denied: confidential_data.txt

Finalmente, verifique as permissões uma última vez para ver o estado somente leitura.

ls -l confidential_data.txt

-r-------- 1 labex labex 19 Jul 21 15:09 confidential_data.txt

Você configurou com sucesso as permissões de arquivo para proteger tanto sua confidencialidade quanto sua integridade.

Demonstrar Integridade de Arquivo com Hashing (MD5/SHA256)

Nesta etapa, você aprenderá a usar hashing criptográfico para verificar a integridade de arquivos. Embora as permissões de arquivo possam impedir que usuários não autorizados modifiquem um arquivo, elas não protegem contra alterações acidentais por um usuário autorizado ou ataques mais sofisticados. Uma função de hash cria uma impressão digital digital única (uma string de caracteres de comprimento fixo) para um arquivo. Mesmo uma alteração de um bit no arquivo produzirá um hash completamente diferente, tornando-o uma excelente ferramenta para detectar adulterações. Usaremos o comando sha256sum, uma ferramenta de hashing padrão e segura no Linux.

Primeiro, certifique-se de estar no diretório correto. Se você estiver continuando da etapa anterior, já deverá estar em ~/project.

Na última etapa, tornamos confidential_data.txt somente leitura para proteger sua integridade. Para demonstrar como o hashing funciona, primeiro precisamos tornar o arquivo gravável novamente para o proprietário. Usaremos chmod para conceder permissões de escrita de volta ao usuário (u+w).

chmod u+w confidential_data.txt
ls -l confidential_data.txt

As permissões agora devem ser -rw-------, indicando que o proprietário pode gravar no arquivo novamente, mantendo a confidencialidade.

-rw------- 1 labex labex 19 Jul 21 15:09 confidential_data.txt

Agora, vamos gerar o hash SHA256 para nosso arquivo original e confiável. Este hash servirá como nossa linha de base para verificações de integridade.

sha256sum confidential_data.txt

O comando exibirá uma longa string de caracteres, que é o hash, seguida pelo nome do arquivo.

106b4d0169831f239fec7a53b072640a2c0b815e00b088bbe44e6689e92cb96d  confidential_data.txt

Para facilitar a verificação posteriormente, é prática comum salvar esse valor de hash confiável em um arquivo separado. Vamos redirecionar a saída do comando para um novo arquivo chamado hashes.sha256.

sha256sum confidential_data.txt > hashes.sha256

Você pode visualizar o conteúdo deste novo arquivo para confirmar que o hash foi salvo.

cat hashes.sha256

106b4d0169831f239fec7a53b072640a2c0b815e00b088bbe44e6689e92cb96d  confidential_data.txt

Agora, vamos simular uma modificação não autorizada. Anexaremos uma nova linha de texto ao nosso arquivo sensível.

echo "This is an unauthorized modification." >> confidential_data.txt

O arquivo confidential_data.txt foi alterado. Para verificar sua integridade, podemos usar o sinalizador -c (ou --check) com sha256sum, dizendo para comparar o hash atual do arquivo com o valor confiável armazenado em hashes.sha256.

sha256sum -c hashes.sha256

Como o conteúdo do arquivo foi alterado, o novo hash não corresponderá ao hash armazenado. O comando relatará uma falha, provando que a integridade do arquivo foi comprometida.

confidential_data.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

Esta técnica poderosa permite verificar de forma rápida e confiável se algum arquivo foi alterado de seu estado original.

Simular Disponibilidade de Serviço e Monitoramento Básico

Nesta etapa, você explorará o princípio da Disponibilidade, o terceiro componente da tríade de segurança CIA. A disponibilidade garante que sistemas e serviços estejam operacionais e acessíveis quando necessário. Você simulará um serviço web simples, aprenderá a verificar se ele está em execução, simulará uma falha de serviço e, em seguida, escreverá um script de monitoramento básico para automatizar a verificação de disponibilidade.

Primeiro, certifique-se de estar no diretório ~/project.

Usaremos o servidor web integrado do Python para simular um serviço em execução. Este comando iniciará um servidor web na porta 8000 e servirá os arquivos no diretório atual. O & no final executa o processo em segundo plano, para que você possa continuar usando seu terminal.

python3 -m http.server 8000 &

Você verá uma mensagem indicando que o processo foi iniciado, juntamente com seu ID de Processo (PID).

[1] 12345

Pressione Enter para continuar.

Seu serviço agora está em execução. Uma maneira básica de verificar se um serviço está em execução é ver se seu processo existe. Podemos usar o comando pgrep para encontrar o PID de um processo pelo nome.

pgrep -f http.server

Isso deve retornar o PID do processo do servidor, confirmando que ele está em execução na memória.

12345

No entanto, um processo em execução não garante que o serviço esteja funcionando corretamente. Uma verificação melhor é tentar se conectar a ele, assim como um usuário faria. Usaremos o comando curl para enviar uma solicitação ao nosso servidor local.

curl http://localhost:8000/confidential_data.txt

Como o serviço está disponível, ele responderá com o conteúdo do arquivo que você criou nas etapas anteriores.

Top Secret Details
This is an unauthorized modification.

Agora, vamos simular uma falha de serviço. Usaremos o comando kill para encerrar o processo do servidor web. Você precisará do PID que encontrou anteriormente.

## Substitua 12345 pelo PID real do comando pgrep
kill 12345

Após executar kill, você poderá ver uma mensagem "Terminated" (Terminado) para o trabalho em segundo plano. Agora, vamos tentar acessar o serviço novamente com curl.

curl http://localhost:8000/confidential_data.txt

Desta vez, o comando falhará porque o serviço não está mais em execução e não pode aceitar a conexão. Isso demonstra uma falta de disponibilidade.

curl: (7) Failed to connect to localhost port 8000 after 0 ms: Connection refused

Finalmente, vamos criar um script de monitoramento simples para automatizar essa verificação. Crie um novo arquivo chamado monitor.sh usando nano.

nano monitor.sh

Insira o seguinte script no editor. Este script usa curl para verificar o serviço. Se ele receber uma resposta bem-sucedida (200 OK), ele relata que o serviço está "UP" (Ativo); caso contrário, relata "DOWN" (Inativo).

#!/bin/bash

## Verifica se o serviço em localhost:8000 está respondendo
if curl -s --head http://localhost:8000 | grep "200 OK" > /dev/null; then
  echo "Service Status: UP"
else
  echo "Service Status: DOWN"
fi

Salve o arquivo e saia do nano pressionando Ctrl+X, depois Y e Enter.

Torne o script executável usando chmod:

chmod +x monitor.sh

Agora, execute seu script de monitoramento. Como o serviço está parado, ele deve relatar "DOWN".

./monitor.sh

Service Status: DOWN

Agora você aprendeu como iniciar um serviço, verificar sua disponibilidade, simular uma falha e criar um script básico para monitorá-lo.

Resumo

Neste laboratório, você ganhou experiência prática com os princípios fundamentais da tríade de segurança CIA (Confidencialidade, Integridade, Disponibilidade) usando ferramentas comuns do Linux. Você aprendeu a impor a Confidencialidade manipulando permissões de arquivo do Linux com o comando chmod, restringindo o acesso a um arquivo confidencial para que apenas o proprietário autorizado pudesse visualizar seu conteúdo. Além disso, você explorou a Integridade primeiro definindo permissões de arquivo para evitar modificações não autorizadas e, em seguida, usando algoritmos de hashing como MD5 e SHA256 para gerar um checksum exclusivo, permitindo verificar se um arquivo não foi adulterado.

O conceito de Disponibilidade foi demonstrado simulando o status operacional de um serviço e realizando monitoramento básico para confirmar que ele estava acessível. Através dessas etapas práticas, você aplicou comandos fundamentais do Linux para implementar e entender na prática os princípios centrais da segurança da informação.