Demonstração de Validação de Entrada e Integridade de Código

Introdução

Neste laboratório, você explorará dois conceitos fundamentais de segurança: validação de entrada e integridade de código. Validação de entrada é a prática de garantir que qualquer entrada que um programa recebe seja segura e bem formatada antes de ser processada. Esta é uma defesa crítica contra uma ampla gama de ataques, incluindo injeção de comandos (command injection). Integridade de código envolve verificar se o código da sua aplicação não foi alterado ou corrompido por uma parte não autorizada.

Você aprenderá esses conceitos através de uma abordagem prática. Primeiro, você criará um script de shell simples que é intencionalmente vulnerável à injeção de comandos. Em seguida, você explorará essa vulnerabilidade para entender o risco. Depois, você protegerá o script implementando a sanitização adequada da entrada. Finalmente, você aprenderá a usar hashes criptográficos para verificar a integridade do seu script, garantindo que ele não foi adulterado.

Criar um Script Simples com Entrada do Usuário

Nesta etapa, você criará um script Bash simples que solicita ao usuário um nome de arquivo e, em seguida, exibe informações detalhadas sobre esse arquivo usando o comando ls -l. Esta versão inicial do script não terá nenhuma verificação de segurança.

Primeiro, use o editor nano para criar um novo arquivo chamado check_file.sh no diretório ~/project.

nano ~/project/check_file.sh

Agora, adicione o seguinte código ao arquivo. Este script solicitará um nome de arquivo, lerá a entrada em uma variável chamada filename e, em seguida, executará ls -l nesse nome de arquivo usando o comando eval. Observe que o uso de eval com entrada do usuário é uma séria vulnerabilidade de segurança.

#!/bin/bash

echo "Por favor, insira um nome de arquivo para verificar:"
read filename
echo "Verificando detalhes para: $filename"
eval "ls -l $filename"

Pressione Ctrl+X, depois Y e Enter para salvar o arquivo e sair do nano.

Em seguida, você precisa tornar o script executável para poder executá-lo. Use o comando chmod para adicionar permissões de execução.

chmod +x ~/project/check_file.sh

Agora, vamos executar o script para vê-lo em ação. Usaremos testfile.txt, que foi criado para você no ambiente de laboratório.

./check_file.sh

O script solicitará sua entrada. Digite testfile.txt e pressione Enter.

Por favor, insira um nome de arquivo para verificar:
testfile.txt
Verificando detalhes para: testfile.txt
-rw-rw-r-- 1 labex labex 0 Aug  4 15:19 testfile.txt

Você criou e executou com sucesso um script simples que recebe entrada do usuário. Na próxima etapa, você verá como este script pode ser explorado.

Simular um Ataque Básico de Injeção de Comandos

Nesta etapa, você verá como o script criado na etapa anterior é vulnerável a um ataque de injeção de comandos. A injeção de comandos ocorre quando um atacante consegue executar comandos arbitrários no sistema operacional host através de uma aplicação vulnerável.

Nosso script é vulnerável porque usa eval para executar um comando que inclui entrada do usuário ($filename) sem verificar primeiro se a entrada é segura. O comando eval trata toda a string como um comando a ser executado, tornando-o particularmente perigoso. Um atacante pode explorar isso fornecendo uma entrada que inclua comandos adicionais do shell.

Vamos executar o script novamente.

./check_file.sh

Desta vez, quando solicitado um nome de arquivo, insira a seguinte string. O ponto e vírgula (;) é um caractere especial no shell que separa comandos.

testfile.txt; whoami

Após pressionar Enter, você verá a seguinte saída:

Por favor, insira um nome de arquivo para verificar:
testfile.txt; whoami
Verificando detalhes para: testfile.txt; whoami
-rw-rw-r-- 1 labex labex 0 Aug  4 15:19 testfile.txt
labex

Observe o que aconteceu. O script primeiro executou ls -l testfile.txt como esperado. No entanto, devido ao ponto e vírgula e ao uso de eval, o shell executou o segundo comando, whoami, que imprimiu o nome de usuário atual (labex). Isso demonstra uma injeção de comandos bem-sucedida. O comando eval tornou isso possível ao tratar toda a entrada como código executável. Um atacante poderia usar essa vulnerabilidade para executar comandos muito mais perigosos.

Observação: Se você usasse ls -l $filename sem eval (como na versão original), o ataque não funcionaria porque o shell trataria testfile.txt; whoami como argumentos separados para ls, resultando em mensagens de erro como "cannot access 'testfile.txt;'" e "cannot access 'whoami'". O comando eval é o que torna a injeção de comandos possível neste exemplo.

Implementar Sanitização de Entrada para Prevenir Injeção

Nesta etapa, você modificará o script para prevenir ataques de injeção de comandos, sanitizando a entrada do usuário e removendo o perigoso comando eval. A sanitização de entrada é o processo de limpar ou filtrar a entrada para remover ou neutralizar caracteres potencialmente maliciosos.

Nossa estratégia será:

1. Remover o perigoso comando eval e usar a execução direta de comandos com aspas adequadas.
2. Verificar se o nome de arquivo de entrada contém apenas caracteres permitidos. Para um nome de arquivo típico, podemos criar uma lista de permissão de caracteres, como letras, números, underscores, hifens e pontos. Rejeitaremos qualquer entrada que contenha outros caracteres, como o ponto e vírgula.

Abra o script check_file.sh novamente com nano.

nano ~/project/check_file.sh

Modifique o script para incluir uma verificação de validação usando uma expressão regular. Substitua o conteúdo existente pelo seguinte código:

#!/bin/bash

echo "Por favor, insira um nome de arquivo para verificar:"
read filename

## Sanitização de entrada: permitir apenas caracteres alfanuméricos, underscores, hifens e pontos.
if [[ "$filename" =~ ^[a-zA-Z0-9_.-]+$ ]]; then
  echo "Verificando detalhes para: $filename"
  ls -l "$filename"
else
  echo "Erro: Nome de arquivo inválido. Entrada maliciosa detectada."
fi

As principais alterações são:

1. Remoção do perigoso comando eval.
2. Adição de aspas adequadas em torno de "$filename" no comando ls.
3. A instrução if com validação de entrada. A expressão [[ "$filename" =~ ^[a-zA-Z0-9_.-]+$ ]] verifica se a variável filename contém apenas os caracteres do conjunto especificado do início (^) ao fim ($).

Pressione Ctrl+X, Y e Enter para salvar as alterações.

Agora, vamos tentar o mesmo ataque novamente. Execute o script:

./check_file.sh

Insira a entrada maliciosa testfile.txt; whoami e pressione Enter.

Por favor, insira um nome de arquivo para verificar:
testfile.txt; whoami
Erro: Nome de arquivo inválido. Entrada maliciosa detectada.

Como você pode ver, o script agora detecta os caracteres inválidos e exibe uma mensagem de erro em vez de executar o comando malicioso whoami. O ataque é prevenido com sucesso.

Verificar Integridade do Script com Hash

Nesta etapa, você aprenderá como verificar a integridade do seu script usando um hash criptográfico. Isso garante que o script não foi modificado ou adulterado por um atacante após você o ter protegido. Usaremos a utilidade sha256sum, que calcula um hash SHA-256.

Primeiro, vamos gerar um hash para o nosso script seguro check_file.sh e salvá-lo em um arquivo. Este arquivo atuará como nossa assinatura "conhecida como boa".

sha256sum ~/project/check_file.sh > ~/project/check_file.sha256

Este comando calcula o hash SHA-256 de check_file.sh e redireciona a saída para um novo arquivo chamado check_file.sha256. Vamos visualizar o conteúdo deste arquivo.

cat ~/project/check_file.sha256

Você verá uma longa string de caracteres seguida pelo nome do arquivo. Esta string é o hash exclusivo do seu script.

e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  /home/labex/project/check_file.sh

(Observação: O valor do seu hash será diferente.)

Agora, vamos simular uma modificação não autorizada. Adicionaremos um comentário simples ao final do script. Mesmo uma pequena alteração como essa deve alterar completamente o hash.

echo "## Um comentário inofensivo" >> ~/project/check_file.sh

O script foi modificado. Para verificar sua integridade, podemos usar sha256sum com a opção -c (check), que lê o hash do nosso arquivo de assinatura e o compara com o hash atual do script.

sha256sum -c ~/project/check_file.sha256

O comando relatará uma falha porque o arquivo foi alterado.

/home/labex/project/check_file.sh: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

Isso confirma que a integridade do script foi comprometida. Essa técnica é essencial para garantir que o código que você está executando é o código em que você confia.

Resumo

Parabéns por completar este laboratório! Você ganhou experiência prática com dois princípios de segurança críticos.

Você aprendeu como identificar e prevenir vulnerabilidades de injeção de comandos implementando a sanitização de entrada. Ao validar a entrada do usuário contra uma lista de permissão de caracteres permitidos, você protegeu com sucesso um script shell vulnerável.

Você também aprendeu como garantir a integridade do código usando hashes criptográficos. Ao gerar um checksum SHA-256 para o seu script, você conseguiu criar uma assinatura verificável que pode detectar quaisquer modificações não autorizadas.

Essas habilidades são fundamentais para escrever código seguro e manter a segurança de qualquer sistema.