---

## 1. Introdução

Arquitetura do LMD, estágios de detecção e plataformas suportadas.

O Linux Malware Detect (LMD) é um scanner de malware para Linux lançado sob a licença GNU GPLv2, projetado em torno das ameaças enfrentadas em ambientes de hospedagem compartilhada. Ele utiliza dados de ameaças de sistemas de detecção de intrusão na borda da rede para extrair malware que está sendo ativamente usado em ataques e gera assinaturas para detecção. Além disso, os dados de ameaças são derivados de envios de usuários com o recurso checkout do LMD e de recursos da comunidade de malware.

O LMD concentra-se nas classes de malware que os produtos tradicionais de antivírus frequentemente não detectam: shells PHP, injetores JavaScript, backdoors codificados em base64, bots de IRC e outras ameaças na camada de aplicação web que visam contas de usuários de hospedagem compartilhada em vez de componentes internos do sistema operacional.

**Estágios de Detecção**
- Correspondência de hash de arquivo MD5 para identificação exata de ameaças
- Correspondência de padrões HEX por meio do mecanismo nativo de grep em lote com workers paralelos
- Varredura de assinatura composta (csig) com lógica booleana de múltiplos padrões (AND/OR/limiar), correspondência sem diferenciar maiúsculas/minúsculas, correspondência ampla (UTF-16LE) e curingas com lacunas limitadas
- Varredura nativa de regras YARA com suporte completo a módulos e regras personalizadas
- Análise estatística de comprimento de strings para detectar ameaças ofuscadas (base64, gzinflate)
- Integração com ClamAV para cobertura estendida com assinaturas ClamAV mantidas pelo LMD

**Varredura e Monitoramento**
- Varrer todos os arquivos, arquivos modificados recentemente ou arquivos de uma lista
- Monitoramento de arquivos em tempo real via inotify do kernel (eventos create/modify/move)
- Varredura de uploads HTTP por meio do hook `inspectFile` do ModSecurity2
- Varredura em segundo plano para operações de grande escala sem supervisão
- Filtragem por regex de inclusão/exclusão por varredura

**Quarentena e Resposta**
- Fila de quarentena com armazenamento de arquivos sem permissões
- Quarentena/restauração em lote por ID de varredura
- Regras de limpeza específicas por assinatura para remoção de malware
- Restauração completa de arquivos (conteúdo, proprietário, permissões, mtime)

**Alertas e Relatórios**
- Alertas por e-mail em HTML + texto com design rfxn unificado (marca azul-petróleo, entradas em cartão)
- Suporte a relay SMTP (TLS/SSL) para ambientes sem MTA local
- Alertas por entrada no Slack Block Kit, Telegram MarkdownV2 e Discord embed
- Modelos de alerta personalizáveis por meio de overrides em `alert/custom.d/`
- Relatórios de varredura com detalhes de detecções por arquivo, tipos de detecção codificados por cores

**Infraestrutura**
- Vinculação automática de assinaturas ClamAV para cobertura de motor duplo
- Cron diário com detecção automática de mais de 12 painéis de controle de hospedagem
- Controle de recursos de CPU/IO (nice, ionice, cpulimit)
- Atualizações automáticas de assinaturas e versão
- Suporte a unit de serviço systemd e script init SysV

### Plataformas Suportadas

O LMD roda em qualquer distribuição Linux com bash e utilitários GNU padrão. Plataformas testadas:

| Plataforma | Sistema Init | Caminho de Configuração do Pacote |
|----------|-------------|---------------------|
| RHEL / Rocky / AlmaLinux 8, 9, 10 | systemd | `/etc/sysconfig/maldet` |
| CentOS 6, 7 | SysV / systemd | `/etc/sysconfig/maldet` |
| Debian 10, 11, 12 | systemd | `/etc/default/maldet` |
| Ubuntu 20.04, 22.04, 24.04 | systemd | `/etc/default/maldet` |
| Gentoo | OpenRC | — |
| Slackware | SysV | — |
| FreeBSD | — | — (parcial; sem inotify) |

---

## 2. Instalação

Instalando, atualizando e removendo o LMD de um sistema.

O script `install.sh` incluído realiza todas as tarefas de instalação. Instalações anteriores são automaticamente copiadas em backup.```bash
./install.sh

### 3.1 Opções Gerais

| Variável | Finalidade | Padrão |
|----------|---------|---------|
| `autoupdate_signatures` | Atualizar assinaturas automaticamente diariamente via cron | `1` |
| `autoupdate_version` | Atualizar automaticamente a versão do LMD diariamente via cron | `1` |
| `autoupdate_version_hashed` | Verificar o hash SHA-256 do executável LMD em relação ao upstream (usa MD5 como fallback) | `1` |
| `sigup_interval` | Horas entre verificações automáticas de atualização de assinaturas via job cron independente (`/etc/cron.d/maldet-sigup`); 0 = desativado | `6` |
| `cron_prune_days` | Dias para reter dados de quarentena/sessão/temporários | `21` |
| `cron_daily_scan` | Habilitar verificação automática diária via cron | `1` |
| `scan_days` | Dias para buscar arquivos modificados em verificações cron diárias | `1` |
| `import_config_url` | URL para baixar substituição de configuração remota | — |
| `import_config_expire` | Expiração de cache da configuração importada (segundos) | `43200` |
| `sig_import_md5_url` | URL para baixar assinaturas MD5 personalizadas | — |
| `sig_import_hex_url` | URL para baixar assinaturas HEX personalizadas | — |
| `sig_import_yara_url` | URL para baixar regras YARA personalizadas | — |
| `sig_import_sha256_url` | URL para baixar assinaturas SHA-256 personalizadas | — |
| `sig_import_csig_url` | URL para baixar assinaturas compostas personalizadas | — |
| `session_legacy_compat` | Gerar arquivos de sessão legados em texto puro juntamente com TSV: `auto` (detectar sessões de formato antigo), `1` (sempre), `0` (apenas TSV) | `auto` |

### 3.2 Alertas

| Variável | Finalidade | Padrão |
|----------|---------|---------|
| `email_alert` | Habilitar alertas por e-mail após verificações | `0` |
| `email_addr` | Endereço do destinatário do alerta | `[email protected]` |
| `email_subj` | Modelo de linha de assunto do e-mail | `maldet alert from $(hostname)` |
| `email_ignore_clean` | Suprimir alertas quando todas as detecções foram limpas | `1` |
| `email_panel_user_alerts` | Enviar alertas de usuário do painel na detecção de ameaças | `0` |
| `email_panel_from` | Cabeçalho From para alertas de usuário do painel | `[email protected]` |
| `email_panel_replyto` | Cabeçalho Reply-To para alertas de usuário do painel | `[email protected]` |
| `email_panel_alert_subj` | Linha de assunto para alertas de usuário do painel | `maldet alert from $(hostname)` |
| `email_format` | Formato do e-mail: `text`, `html` ou `both` | `html` |
| `smtp_relay` | URL do relay SMTP (ex.: `smtps://smtp.gmail.com:465`) | — |
| `smtp_from` | Endereço do remetente para entrega via relay SMTP | — |
| `smtp_user` | Nome de usuário de autenticação SMTP | — |
| `smtp_pass` | Senha de autenticação SMTP | — |
| `slack_alert` | Habilitar alertas de upload de arquivos no Slack | `0` |
| `slack_subj` | Nome do arquivo para upload no Slack | `maldet alert from $(hostname)` |
| `slack_token` | Token da API do Slack Bot (escopos: `files:write`, `files:read`) | — |
| `slack_channels` | Lista separada por vírgulas de nomes ou IDs de canais | `maldetreports` |
| `telegram_alert` | Habilitar alertas no Telegram | `0` |
| `telegram_bot_token` | Token da API do Bot do Telegram | — |
| `telegram_channel_id` | ID do chat ou grupo do Telegram | — |
| `discord_alert` | Habilitar alertas via webhook do Discord | `0` |
| `discord_webhook_url` | URL do webhook do Discord para envio de alertas | — |

### 3.3 Opções de Varredura

| Variável | Finalidade | Padrão |
|----------|---------|---------|
| `scan_hashtype` | Algoritmo de hash para o estágio 1: `auto`, `sha256`, `md5`, `both` | `auto` |
| `scan_max_depth` | Profundidade máxima de diretórios para o find | `15` |
| `scan_min_filesize` | Tamanho mínimo de arquivo para verificar | `24` bytes |
| `scan_max_filesize` | Tamanho máximo de arquivo para verificar | `2048k` |
| `scan_hexdepth` | Profundidade em bytes para correspondência de assinaturas HEX | `262144` |
| `scan_hex_chunk_size` | Arquivos por micro-lote na varredura HEX+CSIG (intervalo: 1024-20480) | `10240` |
| `scan_csig` | Habilitar varredura de assinatura composta (csig) (somente modo nativo) | `1` |
| `scan_workers` | Workers paralelos para as passagens de varredura MD5, SHA-256, HEX e CSIG | `auto` |
| `scan_cpunice` | Prioridade nice para o processo de varredura (-19 a 19) | `19` |
| `scan_ionice` | Prioridade da classe de agendamento de E/S (0-7) | `6` |
| `scan_cpulimit` | Limite rígido de porcentagem de CPU (0=desativado) | `0` |
| `scan_ignore_root` | Ignorar arquivos de propriedade do root nas varreduras (não aplicado no modo monitor por padrão; consulte `monitor_scan_owner_filters`) | `1` |
| `scan_ignore_user` | Ignorar arquivos pertencentes a usuários específicos | — |
| `scan_ignore_group` | Ignorar arquivos pertencentes a grupos específicos | — |
| `scan_user_access` | Permitir que usuários não root executem varreduras | `0` |
| `scan_user_access_minuid` | UID mínimo para criação de diretórios de usuário via --mkpubpaths | `100` |
| `scan_find_timeout` | Tempo limite para geração da lista de arquivos via find (0=desativado, mínimo 60s, 14400=4h recomendado) | `0` |
| `scan_export_filelist` | Salvar resultados do find em tmp/find_results.last | `0` |
| `scan_tmpdir_paths` | Caminhos temporários com escrita global incluídos nas varreduras -a/-r | `/tmp /var/tmp /dev/shm /var/fcgi_ipc` |
| `string_length_scan` | Habilitar análise estatística de comprimento de strings | `0` |
| `string_length` | Comprimento mínimo suspeito de string | `150000` |
| `scan_progress_log_interval` | Segundos entre checkpoints do log de progresso durante varreduras em segundo plano (0=desativado) | `60` |
| `scan_meta_cleanup_age` | Horas para reter arquivos de metadados de varreduras concluídas/encerradas (0=desativado) | `48` |
| `maint_compress_age` | Dias antes que arquivos de sessão concluídos sejam compactados com gzip (0=desativado) | `30` |
| `maint_archive_age` | Dias antes que sessões compactadas sejam agrupadas em arquivos mensais (0=desativado) | `90` |

### 3.4 Varredura YARA

A varredura YARA nativa invoca o binário `yara` (ou `yr` do YARA-X) independentemente do ClamAV, suportando módulos YARA completos, regras compiladas e arquivos de regras personalizados que o subconjunto limitado de YARA do ClamAV não consegue processar. Quando ambos estão disponíveis, `yr` (YARA-X) é preferido. Quando definido como `auto`, o YARA nativo é habilitado apenas quando o ClamAV não está disponível e um binário yara/yr é encontrado, evitando avaliação duplicada de regras.

| Variável | Finalidade | Padrão |
|----------|---------|---------|
| `scan_yara` | Habilitar o estágio de varredura YARA nativo: `auto` (detectar binário, fallback para ClamAV), `0` (desativado), `1` (ativado) | `auto` |
| `scan_yara_timeout` | Tempo limite em segundos (0=sem tempo limite) | `300` |
| `scan_yara_scope` | Escopo das regras quando o ClamAV também está ativo: `all` (varredura nativa completa) ou `custom` (somente regras personalizadas nativamente, ClamAV processa rfxn.yara) | `custom` |
| `sig_import_yara_url` | URL para baixar regras YARA personalizadas na atualização de assinaturas | — |

**Regras YARA personalizadas** podem ser colocadas em dois locais, ambos preservados entre atualizações:
- `sigs/custom.yara` — regras de arquivo único
- `sigs/custom.yara.d/` — diretório drop-in para arquivos de regras `.yar` e `.yara`

Compatível com conjuntos de regras de terceiros, como [YARA Forge](https://yarahq.github.io/) e [Signature Base](https://github.com/Neo23x0/signature-base). Regras compiladas (saída do `yarac`) também são suportadas via `sigs/compiled.yarc`.

**Varredura em lote:** YARA 4.0+ e todas as versões do YARA-X usam `--scan-list` para varredura eficiente de arquivos em lote. Versões mais antigas do YARA recorrem automaticamente à varredura arquivo por arquivo.

Habilite em tempo de execução sem editar a configuração:```bash
maldet -co scan_yara=1 -a /home/?/public_html

### 4.1 Códigos de Saída

| Código | Significado |
|------|---------|
| `0` | Sucesso, sem detecções de malware |
| `1` | Erro ou todos os caminhos de digitalização inexistentes |
| `2` | Detecções de malware encontradas |

**Exemplos:**```bash
# Scan all files under user web roots
maldet -a /home/?/public_html

# Scan recent files with auto-quarantine and YARA enabled
maldet -co quarantine_hits=1,scan_yara=1 -r /home/?/public_html 2

# Background scan with email alert to specific address
maldet -b -co [email protected] -a /var/www

# View the most recent scan report
maldet -e

# Email a specific report
maldet --mailto [email protected] -e 050910-1534.21135

# Output scan report as JSON (pipe to jq for formatting)
maldet --format json -e 050910-1534.21135

# List all reports as JSON
maldet --format json -e list

# Shorthand JSON output (equivalent to --format json -e)
maldet --json-report 050910-1534.21135

# Restore all quarantined files from a scan
maldet -s 050910-1534.21135

**Retomada de checkpoint:** `--stop` grava um arquivo de checkpoint registrando o estágio da varredura, contagem de detecções, opções de configuração e progresso por worker. `--continue` valida o checkpoint, avisa se as assinaturas mudaram, reconstrói a lista de arquivos a partir do estado atual do sistema de arquivos, restaura detecções anteriores e retoma a varredura a partir do estágio interrompido. Os workers HEX retomam na granularidade de chunk (~30s de trabalho perdido por worker).

**Suporte a engine:** A engine nativa (workers HEX/CSIG/hash) e o `clamscan` autônomo suportam todas as operações de ciclo de vida. O ClamAV baseado em daemon (`clamdscan`/`clamd`) suporta apenas `--kill` — `--pause` e `--stop` são rejeitados com uma mensagem de erro porque o estado de I/O do daemon é opaco e compartilhado com outros clientes.

---

## 5. Opções de Ignorar

Excluindo caminhos, tipos de arquivo e assinaturas de varreduras e monitoramento.

Quatro arquivos de ignorar controlam o que é excluído da varredura:

| Arquivo | Formato | Finalidade |
|------|--------|---------|
| `ignore_paths` | Caminhos separados por linha | Excluir diretórios ou arquivos de varreduras |
| `ignore_file_ext` | Extensões separadas por linha | Excluir extensões de arquivo (`.js`, `.css`) |
| `ignore_sigs` | Padrões separados por linha | Ignorar assinaturas correspondentes (regex, correspondência de substring) |
| `ignore_inotify` | Caminhos literais separados por linha | Excluir eventos de monitoramento inotify |

Todos os arquivos de ignorar estão localizados em `/usr/local/maldetect/`.

**Exemplos:**```
# ignore_paths
/home/user/public_html/cgi-bin

# ignore_file_ext
.js
.css

# ignore_sigs
base64.inject.unclassed

# ignore_inotify (user-owned — your additions only)
/home/user/public_html/cache/
backup-

# ignore_inotify.defaults (LMD-managed — refreshed on every upgrade)
# Ships under /usr/local/maldetect/internals/ with curated defaults
# for systemd-private tmpdirs, MariaDB temp tables, Redis, ClamAV, etc.
# Do NOT edit — add your own entries to ignore_inotify instead.

**Como funciona:**

`maldet -m` executa um processo supervisor em primeiro plano por padrão. O supervisor gerencia um filho `inotifywait` e lida com recuperação de falhas, recarregamentos de configuração e alertas de resumo. Use `-b` para daemonizar o supervisor e retornar imediatamente.

1. `monitor_init()` configura observações inotify em todos os arquivos sob os caminhos monitorados
2. Os eventos de arquivo são enfileirados e varridos em lote a cada `inotify_sleep` segundos (padrão: 15)
3. A configuração é recarregada a cada `inotify_reloadtime` segundos (padrão: 3600)
4. Os limites do kernel `max_user_watches` e `max_user_instances` são ajustados automaticamente para desempenho ideal
5. Se `inotifywait` falhar, o supervisor o reinicia com backoff exponencial (2, 4, 8, 16, 32 segundos); após 3 falhas consecutivas, o supervisor é encerrado

**Alertas de resumo** são enviados periodicamente no intervalo definido por `digest_interval` (padrão: `24h`). Se a contagem de detecções desde o último resumo exceder `digest_escalate_hits`, um alerta de escalonamento imediato é enviado (padrão: `0`, desabilitado).

**Caminhos aditivos:** Para observar caminhos adicionais sem editar `conf.maldet`, adicione-os um por linha ao arquivo referenciado por `monitor_paths_extra` (padrão: `/usr/local/maldetect/monitor_paths.extra`). Eles são mesclados à lista de observação principal a cada recarga de configuração.

Ao usar o modo `users`, apenas subdiretórios que correspondem a `inotify_docroot` (padrão: `public_html,public_ftp`) são monitorados, além dos diretórios temporários do sistema `/tmp`, `/var/tmp` e `/dev/shm`.

**Arquivos de ignorar (inotify):** As exclusões do monitor unem dois arquivos — o `ignore_inotify` de propriedade do usuário e o `ignore_inotify.defaults` gerenciado pelo LMD em `/usr/local/maldetect/internals/ignore_inotify.defaults`. Ambos são separados por linhas e suportam comentários `#` + linhas em branco. O `ignore_inotify` de propriedade do usuário aceita POSIX ERE (regex estendido) por padrão — âncoras (`^`, `$`) e curingas (`.*`, `.+`) funcionam. Para excluir um caminho literal contendo metacaracteres de regex, prefixe a entrada com `literal:` (ex.: `literal:/tmp/app.cache`). O `ignore_inotify.defaults` gerenciado pelo LMD é tratado como substrings literais — suas entradas selecionadas são escapadas automaticamente no momento do carregamento. O arquivo de padrões é sobrescrito a cada atualização do LMD; adicione exclusões específicas do site apenas ao `ignore_inotify`.

---

## 8. Sistema de Assinaturas

Tipos de assinatura, convenções de nomenclatura, atualizações e arquivos de regras personalizados.

O LMD é fornecido com cinco tipos de assinatura:

| Tipo | Arquivo | Formato | Contagem |
|------|---------|---------|---------|
| Hashes MD5 | `sigs/md5v2.dat` | `HASH:SIZE:{MD5}sig.name.N` | ~14.801 |
| Hashes SHA-256 | `sigs/sha256v2.dat` | `HASH:SIZE:{SHA256}sig.name.N` | CDN |
| Padrões HEX | `sigs/hex.dat` | `HEXSTRING:{HEX}sig.name.N` | ~2.054 |
| Assinaturas compostas | `sigs/csig.dat` | `SUBSIG1\|\|SUBSIG2:signame` | CDN |
| Regras YARA | `sigs/rfxn.yara` | sintaxe YARA | ~783 regras |
| YARA compilada | `sigs/compiled.yarc` | saída do `yarac` | opcional |

Assinaturas compatíveis com ClamAV também são mantidas:
- `sigs/rfxn.hdb` — formato MD5 ClamAV
- `sigs/rfxn.ndb` — formato HEX ClamAV
- `sigs/rfxn.hsb` — formato SHA-256 ClamAV (requer ClamAV >= 0.97)

**Convenção de nomenclatura de assinaturas:** `{TYPE}category.name.variant_number`

As categorias incluem: `bin.` (binário), `c.` (linguagem C), `exp.` (exploit), `php.` (PHP), `js.` (JavaScript), `perl.` (Perl), `html.` (phishing), `base64.inject.`, `gzbase64.`

**Prefixos de detecção nos relatórios de varredura:**

| Prefixo | Origem |
|---------|--------|
| `{MD5}` | correspondência de hash MD5 (estágio 1) |
| `{SHA256}` | correspondência de hash SHA-256 (estágio 1) |
| `{HEX}` | correspondência de padrão HEX (estágio 2) |
| `{CSIG}` | correspondência de assinatura composta (estágio 2.5) |
| `{SA}` | análise estatística (comprimento da string) |
| `{YARA}` | varredura YARA nativa (`scan_yara=1`) |
| `{CAV}` | mecanismo ClamAV (clamd/clamscan) |

### 8.1 Atualizações de Assinaturas

As assinaturas são atualizadas diariamente por meio do cron job ou manualmente:```bash
maldet -u            # update signatures
maldet -u --force    # force update even if current

**Nomeação de arquivos em quarentena:** `FILENAME.INODE` (por exemplo, `config.php.23754`)

Para varreduras não-root (por exemplo, verificação de upload do ModSecurity2), os dados de quarentena são armazenados em `/usr/local/maldetect/pub/USERNAME/quar/`. Use a flag `-U` para interagir com a quarentena não-root:```bash
maldet -U nobody -s 112012-0032.13771

Envios maliciosos são rejeitados com uma ação de negação e registrados no log de auditoria do ModSecurity. Nenhum argumento de modo é necessário — `hookscan.sh` usa o modo ModSecurity por padrão para compatibilidade retroativa. Tanto o ModSecurity v2 quanto o v3 (libmodsecurity) usam o mesmo contrato `popen()`.

### 10.2 pure-ftpd```bash
# pure-ftpd.conf (or command-line flags):
CallUploadScript yes

# Start the upload-script daemon:
pure-uploadscript -r /usr/local/maldetect/hookscan.sh -B

Os três campos separados por dois-pontos são: modelo de comando, regex de acionamento e regex de captura de nome. Quando malware é detectado, o Exim rejeita a mensagem usando o nome da assinatura capturado.

### 10.5 API Genérica

Para integrações personalizadas, varredura em lote e uso por terceiros:```bash
# Single file scan
hookscan.sh generic /path/to/file
# Exit: 0 = clean, 1 = error, 2 = infected
# Stdout: CLEAN: /path, INFECTED: signame /path, ERROR: reason

# Batch scan from a file list
hookscan.sh generic --list /tmp/filelist.txt

# Batch scan from stdin
find /uploads -newer /tmp/marker -type f | hookscan.sh generic --stdin

Os alertas de teste usam o pipeline de renderização real com dados sintéticos. A linha de assunto é prefixada com `[TEST]`. O isolamento de canal garante que apenas o canal especificado seja acionado.

### 10.8 Resumo de Hooks

As detecções de hooks são resumidas por meio de alertas de resumo periódicos:```bash
# On-demand digest (reads all sources: monitor + hooks)
maldet --digest

# View hook scan activity
maldet --report hooks                    # last 24 hours
maldet --report hooks --last 7d          # last 7 days
maldet --report hooks --mode modsec      # filter by mode

Consulte `man maldet`(1) para o esquema JSON v1.2 (formato uniforme `{schema_version, scanner, host, reports[]}` tanto em `-e SCANID` quanto em `-e list`).

### Detecção de Painel de Hospedagem

O cron diário detecta automaticamente 12+ painéis de controle de hospedagem e ajusta os caminhos de varredura. Consulte [6. Cron Diário](#6-cron-daily) para a matriz completa de painéis.

---

## Licença

LMD é desenvolvido e suportado de forma voluntária por Ryan MacDonald [[email protected]].

O Linux Malware Detect (LMD) é distribuído sob a GNU General Public License (GPL) v2
sem restrições de uso ou redistribuição. A declaração de direitos autorais e a GNU GPL
estão incluídas no arquivo `COPYING.GPL`. Crédito deve ser dado para trabalhos derivados,
conforme exigido pela GNU GPL.

---

## Suporte

O repositório de código-fonte do LMD está em: https://github.com/rfxn/linux-malware-detect

Bugs, solicitações de funcionalidades e dúvidas gerais podem ser registrados como issues no GitHub ou enviados para [email protected].

A página oficial do projeto está em: https://www.rfxn.com/projects/linux-malware-detect/