> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/pt-br/post-exploitation/linux-persistence.md).

# Persistência no Linux

Persistência é a fase pós-exploração em que o acesso se torna repetível após o primeiro shell. Em engajamentos reais, use essas técnicas somente quando estiverem explicitamente no escopo, documente cada alteração e remova toda a persistência antes de encerrar o teste.

{% hint style="warning" %}
Persistência altera contas de usuário, caminhos de login, tarefas agendadas, arquivos de inicialização ou web roots. Trate cada comando como uma ação de laboratório ou de avaliação autorizada e mantenha uma nota de limpeza para cada alteração que fizer.
{% endhint %}

## Mapa Rápido

| Método                           | Melhor Uso                                                                   | Principal Evidência                                                      |
| -------------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| Manipulação de contas de usuário | Persistência controlada em laboratório ou teste de recuperação.              | `/etc/passwd`, `/etc/shadow`, `/etc/group`, arquivos drop-in do sudoers. |
| Chaves autorizadas do SSH        | Acesso confiável baseado em chave para um usuário conhecido.                 | `~/.ssh/authorized_keys`, permissões de arquivo, logs do SSH.            |
| Tarefas cron                     | Repita comandos benignos de validação em um agendamento.                     | `/etc/crontab`, `/etc/cron.d/*`, crontab do usuário.                     |
| Scripts de inicialização         | Execução após reinicialização ou inicialização do serviço.                   | `/etc/rc.local`, unidades do systemd, arquivos de perfil.                |
| Perfis do shell                  | Dispara no login interativo.                                                 | `.bashrc`, `.profile`, `/etc/profile`.                                   |
| Validação de acesso web          | Confirme de forma segura web roots graváveis e execução no lado do servidor. | Arquivo no web root, logs de acesso, usuário do servidor web.            |

## Manipulação de Conta de Usuário

Criar uma conta controlada gera muito ruído, é fácil de detectar e geralmente só é aceitável em laboratórios ou quando as regras de engajamento permitem explicitamente.

### Criar Um Novo Usuário Privilegiado

```bash
useradd -m -s /bin/bash assessment-user
usermod -aG sudo assessment-user
passwd assessment-user
```

Debian/Ubuntu:

```bash
adduser assessment-user sudo
```

CentOS/RHEL:

```bash
usermod -aG wheel assessment-user
```

### Modificar Um Usuário Existente

```bash
usermod -s /bin/bash user
usermod -aG sudo user
echo "user ALL=(ALL:ALL) ALL" > /etc/sudoers.d/user
chmod 440 /etc/sudoers.d/user
passwd user
```

### Validar E Fazer Limpeza

```bash
id assessment-user
groups assessment-user
sudo -l -U assessment-user
```

Limpeza:

```bash
deluser assessment-user sudo 2>/dev/null
userdel -r assessment-user
rm -f /etc/sudoers.d/user
```

## Persistência SSH

A persistência por chave SSH é mais limpa do que alterações de senha, mas ainda é altamente visível no monitoramento de integridade de arquivos e nos logs do SSH.

### Chaves Autorizadas

Para um usuário normal:

```bash
mkdir -p /home/user/.ssh
echo "ssh-rsa AAAAB3NzaC1yc2EA... assessment-key" >> /home/user/.ssh/authorized_keys
chmod 700 /home/user/.ssh
chmod 600 /home/user/.ssh/authorized_keys
chown -R user:user /home/user/.ssh
```

Para root, somente quando explicitamente autorizado:

```bash
mkdir -p /root/.ssh
echo "ssh-rsa AAAAB3NzaC1yc2EA... assessment-key" >> /root/.ssh/authorized_keys
chmod 700 /root/.ssh
chmod 600 /root/.ssh/authorized_keys
```

### Porta SSH Secundária

Adicionar uma segunda porta é ruidoso e deve ser documentado claramente:

```bash
echo "Port 22" >> /etc/ssh/sshd_config
echo "Port 2222" >> /etc/ssh/sshd_config
systemctl restart sshd
```

Validação:

```bash
ss -tuln | grep ':22\|:2222'
ssh -i id_rsa user@target -p 2222
```

Limpeza:

```bash
sed -i '/Port 2222/d' /etc/ssh/sshd_config
systemctl restart sshd
```

## Persistência via Cron

A persistência via cron é útil em laboratórios porque é fácil de demonstrar e fácil de remover. Em ambientes reais, tarefas cron são frequentemente monitoradas.

### Cron em todo o sistema

```bash
echo "* * * * * root /opt/assessment/validate-access.sh" >> /etc/crontab
```

### Cron do Usuário

```bash
(crontab -l 2>/dev/null; echo "* * * * * /opt/assessment/validate-access.sh") | crontab -
```

### `/etc/cron.d`

```bash
echo "* * * * * root /opt/assessment/validate-access.sh" > /etc/cron.d/system-update
chmod 644 /etc/cron.d/system-update
```

Limpeza:

```bash
crontab -l | grep -v '/opt/assessment/validate-access.sh' | crontab -
rm -f /etc/cron.d/system-update
sed -i '/validate-access.sh/d' /etc/crontab
```

## Scripts de inicialização

A persistência de inicialização é executada após a inicialização ou durante a inicialização do login/sessão.

### `rc.local`

```bash
cat > /etc/rc.local <<'EOF'
#!/bin/bash
/opt/assessment/validate-access.sh &
exit 0
EOF
chmod +x /etc/rc.local
```

### Perfis do Shell

Perfil do usuário:

```bash
echo "nohup /opt/assessment/validate-access.sh >/dev/null 2>&1 &" >> ~/.bashrc
```

Perfil global:

```bash
echo "nohup /opt/assessment/validate-access.sh >/dev/null 2>&1 &" >> /etc/profile
```

Limpeza:

```bash
sed -i '/validate-access.sh/d' ~/.bashrc
sed -i '/validate-access.sh/d' /etc/profile
rm -f /etc/rc.local
```

## Validação de Acesso Web

Um web root gravável pode fornecer acesso repetível se o servidor executar o código enviado. Não armazene payloads de web shell ativos em anotações; em vez disso, documente o caminho, o ambiente de execução, a solicitação de validação, os logs e a limpeza.

### Padrão de Documentação Segura

| Campo                    | Exemplo                                                                                           |
| ------------------------ | ------------------------------------------------------------------------------------------------- |
| Raiz web                 | `/var/www/html/`  ou `/srv/www/`                                                                  |
| Caminho gravável         | `/var/www/html/images/`                                                                           |
| Ambiente de execução     | PHP, Python CGI, ASPX, JSP                                                                        |
| Nome de arquivo de teste | Um nome de arquivo de avaliação claramente identificado                                           |
| Solicitação de validação | Uma solicitação inofensiva que comprove a execução no lado do servidor, como retornar o UID atual |
| Comando de limpeza       | Comando exato de remoção e caminhos de log para revisar                                           |

### Checklist de Implantação

```bash
ls -la /var/www/ /srv/www/ 2>/dev/null
find /var/www /srv/www -type d -writable 2>/dev/null
find /var/www /srv/www -type f -mtime -1 -ls 2>/dev/null
```

A validação deve comprovar a execução com a ação menos invasiva possível e, em seguida, remover o arquivo imediatamente.

Limpeza:

```bash
rm -f /path/to/authorized-test-file
find /var/www /srv/www -type f -mtime -1 -ls 2>/dev/null
grep -R "authorized-test" /var/log/apache2 /var/log/httpd /var/log/nginx 2>/dev/null
```

## Notas de Relato

Registrar:

1. Método exato de persistência utilizado.
2. Caminhos de arquivo alterados.
3. Usuário, grupo e permissões antes e depois.
4. Comando de validação e resultado.
5. Comando de limpeza e confirmação.

## Checklist Rápido de Limpeza

```bash
grep -R "assessment-key\|validate-access.sh\|authorized-test" /etc /home /root /var/www /srv/www 2>/dev/null
find /etc/cron* -type f -mtime -7 -ls 2>/dev/null
find /var/www /srv/www -type f -mtime -7 -ls 2>/dev/null
last
journalctl -u ssh -n 100 2>/dev/null
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://hacking-notes.jord4n.pro/pt-br/post-exploitation/linux-persistence.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
