Um atacante com acesso a um servidor Linux pode manipular, ou talvez até arruinar, qualquer coisa
a que tenha acesso. Enquanto muitos ataques sutis possam fornecer um valor significativo para um
hacker, a maioria dos ataques deixam rastros. Esses rastros, é claro, também podem ser
manipulados e evitados através de métodos usando shell scripting.
O encontro de evidências de um ataque pode começar com um rastro deixado por um atacante
como, por exemplo, a data de modificação de um arquivo. Toda vez que um arquivo é criado,
modificado ou “tocado” na terminologia Unix, ele atualiza a hora em que o arquivo foi modificado.
Todo arquivo dentro de um sistema de arquivos Linux contém uma data de modificação armazenada
em algum lugar.

Para o administrador de sistemas, arquivos que de repente exibem um horário de modificação
recente podem alertá-lo sobre um possível ataque e fazê-lo agir bloqueando o sistema. Felizmente
para o atacante, os horários de modificação não são infalíveis. Esses horários de modificação podem
ser falsificados. Uma das maneiras do invasor poder automatizar o processo de backup e restaurar
os horários de modificação é escrevendo um shell script.

1º Passo – Vendo e manipulando timestamps

Várias ferramentas incluídas na maioria dos sistemas Linux nos permitem visualizar e modificar
rapidamente os timestamps (horários de modificação) dos arquivos. A ferramenta mais relevante
para afetar essa propriedade é chamada de touch. Este comando nos permite criar um novo arquivo
ou atualizar a última vez que um arquivo ou grupo de arquivos foi “tocado”.
touch arquivo

Executando o comando acima criará um novo arquivo chamado “arquivo” se ele ainda não existir, e
se existir, ele atualizará a data de modificação com a hora atual do sistema. Nós também podemos
usar um curinga, como no comando abaixo.

touch *

Este comando atualizará o timestamp de cada arquivo na pasta na qual ele foi executado.
Depois de criar ou modificar o nosso arquivo, existem algumas maneiras de ver seus detalhes. O
primeiro deles é usando o comando stat.

stat arquivo

 

O comando stat retorna algumas informações sobre o arquivo, incluindo horários de acesso,
modificação e alteração. Para um lote de arquivos, também podemos visualizar os timestamps
de vários arquivos dentro de uma pasta com parâmetros do comando ls. Este comando lista
arquivos e a opção -l, ou “long”, também inclui os timestamps desses arquivos na sua saída.

Agora que podemos definir os timestamps atuais e visualizar aqueles que já foram
configurados, também podemos usar o comando touch para definir um timestamp falsificado.
Podemos fazer isso usando a opção -d e definindo um tempo específico em um formato ANO-M
ÊS-DIA seguido de horas, minutos e segundos.

touch -d “2001-01-01 20:00:00” arquivo.txt

Podemos confirmar usando o comando ls:

ls -l arquivo.txt

Embora seja útil em casos de uso individual, seria muito ineficaz usar esta técnica para alterar
manualmente vários e diferentes timestamps em um servidor depois de editar os arquivos.
Podemos automatizar esse processo com um shell script.

2º Passo – Organizando o shell script

Antes de começarmos o script, devemos considerar exatamente quais processos nós
precisamos realizar. Para esconder rastros em um servidor, o invasor precisaria fazer backup
dos timestamps originais de uma pasta, escrevendo-os num arquivo, e então restaurá-los aos
arquivos originais depois de ter modificado quaisquer arquivos durante a invasão.
Essas duas funções diferentes podem ser ativadas por diferentes entradas ou argumentos.
Como nosso script funcionará com base nesses argumentos, também queremos ter uma
maneira de lidar com erros. Isso nos deixa com um total de três cursos de ação em potencial,
dependendo da entrada do usuário.

• nenhum argumento: mensagem de erro de retorno
• salvar timestamps: salvar timestamps em um arquivo
• restaurar timestamps: restaurar os timestamps originais dos arquivos de acordo com a lista
salva

Podemos começar a escrever o script no editor de texto de nossa escolha.

3º Passo – O script

[NOTA] Não falarei sobre muitos detalhes considerados triviais. Suponho que quem esteja
lendo este artigo tenha uma certa base de shell script.

Lidando com erros:

[ $# -eq 0 ] indica que não existem argumentos passados para o script.

 

Salvando timestamps em um arquivo:

 

O script salvará os timestamps no arquivo “bkp-timestamps”. Se esse arquivo já existir, será
deletado antes de um novo backup.
De início podemos guardar a saída de ls -l em bkp-timestamps, mas como para nossos
propósitos apenas a data e o nome do arquivo são necessários, vamos primeiro filtrar a saída
de ls -l com ajuda do comando sed. Um exemplo com a saída ls -l:

ls -l arquivo.txt
-rw-r–r– 1 root root 0 Jan 1 2001 arquivo.txt

O comando sed ‘s/^.*Jan/Jan/p’ aplicado a uma string, vai descartar tudo o que houve antes
de ‘Jan’. Combinando com o comando ls -l através de pipe, temos:

ls -l arquivo.txt | sed ‘s/^.*Jan/Jan/p’
Jan 1 2001 arquivo.txt

Entretanto, como usaremos o comando touch para restaurar depois os timestamps originais,
precisamos salvar o mês em forma de número ao invés de uma abreviação. Faremos uma
pequena mudança no comando sed:

 

ls -l arquivo.txt | sed ‘s/^.*Jan/01/p’
01 1 2001 arquivo.txt

Agora aplicando para todos os meses do ano:

 

sed -n
‘s/^.*Jan/01/p;s/^.*Feb/02/p;s/^.*Mar/03/p;s/^.*Apr/04/p;s/^.*May/05/p;s/^.*Jun/06/p;s
/^.*Jul/07/p;s/^.*Aug/08/p;s/^.*Sep/09/p;s/^.*Oct/10/p;s/^.*Nov/11/p;s/^.*Dec/12/p;’

 

Assim usamos:

ls -l | sed -n
‘s/^.*Jan/01/p;s/^.*Feb/02/p;s/^.*Mar/03/p;s/^.*Apr/04/p;s/^.*May/05/p;s/^.*Jun/06/p;s
/^.*Jul/07/p;s/^.*Aug/08/p;s/^.*Sep/09/p;s/^.*Oct/10/p;s/^.*Nov/11/p;s/^.*Dec/12/p;’ >>
bkp-timestamps

Para salvar os dados em bkp-timestamps.

Para saber mais sobre o comando sed: http://aurelio.net/sed/

Restaurando os timestamps originais:

 

Aqui o script lê cada linha do arquivo, pegando os dados como a data e nome do arquivo para
então usar o comando touch e restaurar os timestamps originais.
Resumo:
Com o script pronto e estando no sistema invadido, use:

./timestamp.sh -s
Faça o que tiver que fazer no sistema e antes de sair, restaure as datas dos arquivos:
./timestamp.sh -r

Tradução e adaptação do artigo original:
https://null-byte.wonderhowto.com/how-to/hackers-cover-their-tracks-exploited-linux-serverwith-
shell-scripting-0180801/