---

## 1. Introduzione

Architettura di LMD, fasi di rilevamento e piattaforme supportate.

Linux Malware Detect (LMD) è uno scanner malware per Linux rilasciato sotto licenza GNU GPLv2, progettato intorno alle minacce affrontate negli ambienti di hosting condiviso. Utilizza dati sulle minacce provenienti da sistemi di rilevamento intrusioni perimetrali di rete per estrarre malware attivamente utilizzati negli attacchi e genera firme per il rilevamento. Inoltre, i dati sulle minacce derivano dalle segnalazioni degli utenti tramite la funzionalità checkout di LMD e dalle risorse della community di malware.

LMD si concentra sulle classi di malware che i prodotti antivirus tradizionali spesso non rilevano: shell PHP, injector JavaScript, backdoor codificate in base64, bot IRC e altre minacce a livello di applicazione web che prendono di mira gli account utente di hosting condiviso piuttosto che le componenti interne del sistema operativo.

**Fasi di rilevamento**
- Corrispondenza hash MD5 dei file per l'identificazione esatta delle minacce
- Corrispondenza di pattern HEX tramite motore grep batch nativo con worker paralleli
- Scansione con firme composte (csig) con logica booleana multi-pattern (AND/OR/soglia), corrispondenza senza distinzione tra maiuscole e minuscole, corrispondenza wide (UTF-16LE) e caratteri jolly con gap delimitato
- Scansione nativa con regole YARA con supporto completo dei moduli e regole personalizzate
- Analisi statistica della lunghezza delle stringhe per rilevare minacce offuscate (base64, gzinflate)
- Integrazione ClamAV per una copertura estesa con firme ClamAV mantenute da LMD

**Scansione e monitoraggio**
- Scansione di tutti i file, dei file modificati di recente o di file da un elenco
- Monitoraggio file in tempo reale tramite inotify del kernel (eventi di creazione/modifica/spostamento)
- Scansione degli upload HTTP tramite hook `inspectFile` di ModSecurity2
- Scansione in background per operazioni su larga scala senza supervisione
- Filtraggio regex di inclusione/esclusione per singola scansione

**Quarantena e risposta**
- Coda di quarantena con archiviazione file a permessi zero
- Quarantena/ripristino in batch per ID di scansione
- Regole di pulizia specifiche per firma per la rimozione del malware
- Ripristino completo dei file (contenuto, proprietario, permessi, mtime)

**Avvisi e report**
- Avvisi email HTML + testo con design rfxn unificato (marchio teal, voci a scheda)
- Supporto relay SMTP (TLS/SSL) per ambienti senza MTA locale
- Avvisi per voce tramite Slack Block Kit, Telegram MarkdownV2, Discord embed
- Modelli di avviso personalizzabili tramite override in `alert/custom.d/`
- Report di scansione con dettagli dei riscontri per file, tipi di riscontro con codifica a colori

**Infrastruttura**
- Collegamento automatico delle firme ClamAV per copertura a doppio motore
- Cron giornaliero con rilevamento automatico di oltre 12 pannelli di controllo per hosting
- Controllo delle risorse CPU/IO (nice, ionice, cpulimit)
- Aggiornamenti automatici di firme e versione
- Supporto per unità di servizio systemd e script di init SysV

### Piattaforme supportate

LMD funziona su qualsiasi distribuzione Linux con bash e utility GNU standard. Piattaforme testate:

| Piattaforma | Sistema di init | Percorso configurazione pacchetto |
|----------|-------------|---------------------|
| 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 | — | — (parziale; senza inotify) |

---

## 2. Installazione

Installazione, aggiornamento e rimozione di LMD da un sistema.

Lo script `install.sh` incluso gestisce tutte le attività di installazione. Le installazioni precedenti vengono automaticamente sottoposte a backup.```bash
./install.sh

### 3.1 Opzioni generali

| Variable | Scopo | Predefinito |
|----------|---------|---------|
| `autoupdate_signatures` | Aggiorna automaticamente le firme ogni giorno tramite cron | `1` |
| `autoupdate_version` | Aggiorna automaticamente la versione di LMD ogni giorno tramite cron | `1` |
| `autoupdate_version_hashed` | Verifica l'hash SHA-256 dell'eseguibile LMD rispetto all'upstream (ricade su MD5) | `1` |
| `sigup_interval` | Ore tra i controlli automatici di aggiornamento firme tramite job cron indipendente (`/etc/cron.d/maldet-sigup`); 0 = disattivato | `6` |
| `cron_prune_days` | Giorni di conservazione dei dati di quarantena/sessione/temporanei | `21` |
| `cron_daily_scan` | Abilita la scansione automatica giornaliera tramite cron | `1` |
| `scan_days` | Giorni a ritroso per la ricerca di file modificati nelle scansioni cron giornaliere | `1` |
| `import_config_url` | URL per scaricare l'override remoto della configurazione | — |
| `import_config_expire` | Scadenza della cache per la configurazione importata (secondi) | `43200` |
| `sig_import_md5_url` | URL per scaricare firme MD5 personalizzate | — |
| `sig_import_hex_url` | URL per scaricare firme HEX personalizzate | — |
| `sig_import_yara_url` | URL per scaricare regole YARA personalizzate | — |
| `sig_import_sha256_url` | URL per scaricare firme SHA-256 personalizzate | — |
| `sig_import_csig_url` | URL per scaricare firme combinate personalizzate | — |
| `session_legacy_compat` | Genera file di sessione legacy in testo semplice insieme ai TSV: `auto` (rileva sessioni in vecchio formato), `1` (sempre), `0` (solo TSV) | `auto` |

### 3.2 Notifiche

| Variable | Scopo | Predefinito |
|----------|---------|---------|
| `email_alert` | Abilita le notifiche email dopo le scansioni | `0` |
| `email_addr` | Indirizzo del destinatario delle notifiche | `[email protected]` |
| `email_subj` | Modello dell'oggetto dell'email | `maldet alert from $(hostname)` |
| `email_ignore_clean` | Sopprime le notifiche quando tutti i rilevamenti sono stati ripuliti | `1` |
| `email_panel_user_alerts` | Invia le notifiche agli utenti del pannello in caso di rilevamento | `0` |
| `email_panel_from` | Intestazione From per le notifiche agli utenti del pannello | `[email protected]` |
| `email_panel_replyto` | Intestazione Reply-To per le notifiche agli utenti del pannello | `[email protected]` |
| `email_panel_alert_subj` | Oggetto per le notifiche agli utenti del pannello | `maldet alert from $(hostname)` |
| `email_format` | Formato email: `text`, `html` o `both` | `html` |
| `smtp_relay` | URL del relay SMTP (es. `smtps://smtp.gmail.com:465`) | — |
| `smtp_from` | Indirizzo del mittente per la consegna tramite relay SMTP | — |
| `smtp_user` | Nome utente per l'autenticazione SMTP | — |
| `smtp_pass` | Password per l'autenticazione SMTP | — |
| `slack_alert` | Abilita le notifiche Slack con caricamento file | `0` |
| `slack_subj` | Nome file per il caricamento su Slack | `maldet alert from $(hostname)` |
| `slack_token` | Token API Bot di Slack (ambiti: `files:write`, `files:read`) | — |
| `slack_channels` | Elenco di nomi o ID di canali separati da virgole | `maldetreports` |
| `telegram_alert` | Abilita le notifiche Telegram | `0` |
| `telegram_bot_token` | Token API Bot di Telegram | — |
| `telegram_channel_id` | ID della chat o del gruppo Telegram | — |
| `discord_alert` | Abilita le notifiche Discord tramite webhook | `0` |
| `discord_webhook_url` | URL del webhook Discord per l'invio delle notifiche | — |

### 3.3 Opzioni di scansione

| Variable | Scopo | Predefinito |
|----------|---------|---------|
| `scan_hashtype` | Algoritmo hash per la fase 1: `auto`, `sha256`, `md5`, `both` | `auto` |
| `scan_max_depth` | Profondità massima delle directory per find | `15` |
| `scan_min_filesize` | Dimensione minima dei file da scansionare | `24` bytes |
| `scan_max_filesize` | Dimensione massima dei file da scansionare | `2048k` |
| `scan_hexdepth` | Profondità in byte per il match delle firme HEX | `262144` |
| `scan_hex_chunk_size` | File per micro-lotto nella scansione HEX+CSIG (intervallo: 1024-20480) | `10240` |
| `scan_csig` | Abilita la scansione con firme combinate (csig) (solo modalità nativa) | `1` |
| `scan_workers` | Worker paralleli per le passate di scansione MD5, SHA-256, HEX e CSIG | `auto` |
| `scan_cpunice` | Priorità nice per il processo di scansione (da -19 a 19) | `19` |
| `scan_ionice` | Priorità della classe di scheduling IO (0-7) | `6` |
| `scan_cpulimit` | Limite rigido della CPU in percentuale (0=disattivato) | `0` |
| `scan_ignore_root` | Salta i file di proprietà di root nelle scansioni (non applicato in modalità monitor per impostazione predefinita; vedi `monitor_scan_owner_filters`) | `1` |
| `scan_ignore_user` | Salta i file di proprietà di utenti specifici | — |
| `scan_ignore_group` | Salta i file di proprietà di gruppi specifici | — |
| `scan_user_access` | Consenti agli utenti non-root di eseguire scansioni | `0` |
| `scan_user_access_minuid` | UID minimo per la creazione delle directory utente di --mkpubpaths | `100` |
| `scan_find_timeout` | Timeout per la generazione dell'elenco file di find (0=disattivato, minimo 60s, consigliato 14400=4 ore) | `0` |
| `scan_export_filelist` | Salva i risultati di find in tmp/find_results.last | `0` |
| `scan_tmpdir_paths` | Percorsi temporanei scrivibili da tutti inclusi nelle scansioni -a/-r | `/tmp /var/tmp /dev/shm /var/fcgi_ipc` |
| `string_length_scan` | Abilita l'analisi statistica della lunghezza delle stringhe | `0` |
| `string_length` | Lunghezza minima sospetta delle stringhe | `150000` |
| `scan_progress_log_interval` | Secondi tra i checkpoint del log di avanzamento durante le scansioni in background (0=disattivato) | `60` |
| `scan_meta_cleanup_age` | Ore di conservazione dei file meta delle scansioni completate/terminate (0=disattivato) | `48` |
| `maint_compress_age` | Giorni prima che i file di sessione completati vengano compressi con gzip (0=disattivato) | `30` |
| `maint_archive_age` | Giorni prima che le sessioni compresse vengano raggruppate in archivi mensili (0=disattivato) | `90` |

### 3.4 Scansione YARA

La scansione YARA nativa richiama il binario `yara` (o `yr` di YARA-X) indipendentemente da ClamAV, supportando moduli YARA completi, regole compilate e file di regole personalizzate che il sottoinsieme YARA limitato di ClamAV non può gestire. Quando entrambi sono disponibili, viene preferito `yr` (YARA-X). Se impostato su `auto`, la scansione YARA nativa viene abilitata solo quando ClamAV non è disponibile e viene trovato un binario yara/yr, evitando la valutazione duplicata delle regole.

| Variable | Scopo | Predefinito |
|----------|---------|---------|
| `scan_yara` | Abilita la fase di scansione YARA nativa: `auto` (rileva il binario, fallback su ClamAV), `0` (disattivata), `1` (attivata) | `auto` |
| `scan_yara_timeout` | Timeout in secondi (0=nessun timeout) | `300` |
| `scan_yara_scope` | Ambito delle regole quando è attivo anche ClamAV: `all` (scansione nativa completa) o `custom` (solo regole personalizzate in modalità nativa, ClamAV gestisce rfxn.yara) | `custom` |
| `sig_import_yara_url` | URL per scaricare regole YARA personalizzate all'aggiornamento delle firme | — |

**Regole YARA personalizzate** possono essere inserite in due posizioni, entrambe mantenute tra gli aggiornamenti:
- `sigs/custom.yara` — regole in file singolo
- `sigs/custom.yara.d/` — directory drop-in per file di regole `.yar` e `.yara`

Compatibile con set di regole di terze parti come [YARA Forge](https://yarahq.github.io/) e [Signature Base](https://github.com/Neo23x0/signature-base). Le regole compilate (output di `yarac`) sono supportate anche tramite `sigs/compiled.yarc`.

**Scansione batch:** YARA 4.0+ e tutte le versioni di YARA-X usano `--scan-list` per una scansione batch efficiente dei file. Le versioni precedenti di YARA ricadono automaticamente sulla scansione file per file.

Abilita in fase di esecuzione senza modificare la configurazione:```bash
maldet -co scan_yara=1 -a /home/?/public_html

### 4.1 Codici di uscita

| Codice | Significato |
|------|---------|
| `0` | Successo, nessun rilevamento di malware |
| `1` | Errore o tutti i percorsi di scansione inesistenti |
| `2` | Trovati rilevamenti di malware |

**Esempi:**```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

**Ripresa del checkpoint:** `--stop` scrive un file di checkpoint registrando la fase di scansione, il conteggio delle rilevazioni, le opzioni di configurazione e l'avanzamento per worker. `--continue` valida il checkpoint, avvisa se le firme sono cambiate, ricostruisce l'elenco dei file dallo stato corrente del filesystem, ripristina le rilevazioni precedenti e riprende la scansione dalla fase interrotta. I worker HEX riprendono con granularità di chunk (~30s di lavoro perso per worker).

**Supporto motore:** Il motore nativo (worker HEX/CSIG/hash) e `clamscan` standalone supportano tutte le operazioni del ciclo di vita. ClamAV basato su daemon (`clamdscan`/`clamd`) supporta solo `--kill` — `--pause` e `--stop` vengono rifiutati con un messaggio di errore poiché lo stato I/O del daemon è opaco e condiviso con altri client.

---

## 5. Opzioni di esclusione

Esclusione di percorsi, tipi di file e firme da scansioni e monitoraggio.

Quattro file ignore controllano ciò che viene escluso dalla scansione:

| File | Formato | Scopo |
|------|--------|---------|
| `ignore_paths` | Percorsi separati da righe | Escludi directory o file dalle scansioni |
| `ignore_file_ext` | Estensioni separate da righe | Escludi estensioni di file (`.js`, `.css`) |
| `ignore_sigs` | Pattern separati da righe | Salta le firme corrispondenti (regex, corrispondenza per sottostringa) |
| `ignore_inotify` | Percorsi letterali separati da righe | Escludi eventi di monitoraggio inotify |

Tutti i file ignore si trovano in `/usr/local/maldetect/`.

**Esempi:**```
# 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.

**How it works:**

`maldet -m` esegue un processo supervisor in primo piano per impostazione predefinita. Il supervisor gestisce un processo figlio `inotifywait` e si occupa del ripristino dopo i crash, del ricaricamento della configurazione e degli avvisi digest. Usa `-b` per trasformare il supervisor in un demone e tornare immediatamente al prompt.

1. `monitor_init()` configura le watch inotify su tutti i file nei percorsi monitorati
2. Gli eventi dei file vengono accodati e scansionati in batch ogni `inotify_sleep` secondi (default: 15)
3. La configurazione viene ricaricata ogni `inotify_reloadtime` secondi (default: 3600)
4. I parametri del kernel `max_user_watches` e `max_user_instances` vengono regolati automaticamente per prestazioni ottimali
5. Se `inotifywait` va in crash, il supervisor lo riavvia con backoff esponenziale (2, 4, 8, 16, 32 secondi); dopo 3 guasti consecutivi il supervisor termina

**Gli avvisi digest** vengono inviati periodicamente all'intervallo impostato da `digest_interval` (default: `24h`). Se il numero di riscontri dall'ultimo digest supera `digest_escalate_hits`, viene inviato un avviso di escalation immediato (default: `0`, disabilitato).

**Percorsi additivi:** Per monitorare percorsi aggiuntivi senza modificare `conf.maldet`, aggiungili uno per riga al file referenziato da `monitor_paths_extra` (default: `/usr/local/maldetect/monitor_paths.extra`). Questi vengono uniti all'elenco di watch principale a ogni ricaricamento della configurazione.

Quando si usa la modalità `users`, vengono monitorate solo le sottodirectory corrispondenti a `inotify_docroot` (default: `public_html,public_ftp`), oltre alle directory temporanee di sistema `/tmp`, `/var/tmp` e `/dev/shm`.

**File di esclusione (inotify):** Le esclusioni di monitoraggio uniscono due file — il file di proprietà dell'utente `/usr/local/maldetect/ignore_inotify` e quello gestito da LMD `/usr/local/maldetect/internals/ignore_inotify.defaults`. Entrambi sono separati da righe e supportano commenti `#` e righe vuote. Il file `ignore_inotify` di proprietà dell'utente accetta POSIX ERE (regex estesa) per impostazione predefinita — le ancore (`^`, `$`) e i metacaratteri jolly (`.*`, `.+`) funzionano. Per escludere un percorso letterale contenente metacaratteri regex, anteponi alla voce il prefisso `literal:` (es. `literal:/tmp/app.cache`). Il file `ignore_inotify.defaults` gestito da LMD viene trattato come sottostringhe letterali — le sue voci curate vengono auto-escaped al momento del caricamento. Il file dei default viene sovrascritto a ogni aggiornamento di LMD; aggiungi le esclusioni specifiche del sito solo a `ignore_inotify`.

---

## 8. Sistema di firme

Tipi di firma, convenzioni di denominazione, aggiornamenti e file di regole personalizzati.

LMD include cinque tipi di firma:

| Tipo | File | Formato | Conteggio |
|------|------|--------|-------|
| Hash MD5 | `sigs/md5v2.dat` | `HASH:SIZE:{MD5}sig.name.N` | ~14,801 |
| Hash SHA-256 | `sigs/sha256v2.dat` | `HASH:SIZE:{SHA256}sig.name.N` | CDN |
| Pattern HEX | `sigs/hex.dat` | `HEXSTRING:{HEX}sig.name.N` | ~2,054 |
| Firme composte | `sigs/csig.dat` | `SUBSIG1\|\|SUBSIG2:signame` | CDN |
| Regole YARA | `sigs/rfxn.yara` | sintassi YARA | ~783 regole |
| YARA compilate | `sigs/compiled.yarc` | output `yarac` | opzionale |

Vengono mantenute anche firme compatibili con ClamAV:
- `sigs/rfxn.hdb` — formato ClamAV MD5
- `sigs/rfxn.ndb` — formato ClamAV HEX
- `sigs/rfxn.hsb` — formato ClamAV SHA-256 (richiede ClamAV >= 0.97)

**Convenzione di denominazione delle firme:** `{TYPE}category.name.variant_number`

Le categorie includono: `bin.` (binario), `c.` (linguaggio C), `exp.` (exploit), `php.` (PHP), `js.` (JavaScript), `perl.` (Perl), `html.` (phishing), `base64.inject.`, `gzbase64.`

**Prefissi dei riscontri nei report di scansione:**

| Prefisso | Origine |
|--------|--------|
| `{MD5}` | corrispondenza hash MD5 (fase 1) |
| `{SHA256}` | corrispondenza hash SHA-256 (fase 1) |
| `{HEX}` | corrispondenza pattern HEX (fase 2) |
| `{CSIG}` | corrispondenza firma composta (fase 2.5) |
| `{SA}` | analisi statistica (lunghezza stringa) |
| `{YARA}` | scansione YARA nativa (`scan_yara=1`) |
| `{CAV}` | motore ClamAV (clamd/clamscan) |

### 8.1 Aggiornamenti delle firme

Le firme vengono aggiornate quotidianamente tramite il job cron o manualmente:```bash
maldet -u            # update signatures
maldet -u --force    # force update even if current

**Denominazione dei file in quarantena:** `FILENAME.INODE` (es. `config.php.23754`)

Per le scansioni non-root (es. scansione upload di ModSecurity2), i dati in quarantena sono memorizzati in `/usr/local/maldetect/pub/USERNAME/quar/`. Usa il flag `-U` per interagire con la quarantena non-root:```bash
maldet -U nobody -s 112012-0032.13771

Gli upload malevoli vengono rifiutati con un'azione deny e registrati nel log di audit di ModSecurity. Non è necessario alcun argomento di modalità — `hookscan.sh` utilizza per impostazione predefinita la modalità ModSecurity per la compatibilità con le versioni precedenti. Sia ModSecurity v2 che v3 (libmodsecurity) usano lo stesso contratto `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

I tre campi separati da due punti sono: modello di comando, regex di attivazione e regex di acquisizione del nome. Quando viene rilevato malware, Exim rifiuta il messaggio utilizzando il nome della firma acquisito.

### 10.5 API generica

Per integrazioni personalizzate, scansioni batch e uso da parte di terze parti:```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

Gli avvisi di test utilizzano la pipeline di rendering reale con dati sintetici. La riga dell'oggetto è prefissata con `[TEST]`. L'isolamento del canale garantisce che venga attivato solo il canale specificato.

### 10.8 Digest degli Hook

Le rilevazioni degli hook vengono riepilogate tramite avvisi digest periodici:```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

Vedi `man maldet`(1) per lo schema JSON v1.2 (forma uniforme `{schema_version, scanner, host, reports[]}` sia con `-e SCANID` che con `-e list`).

### Rilevamento dei Pannelli di Hosting

Il cron giornaliero rileva automaticamente 12+ pannelli di controllo hosting e adatta i percorsi di scansione. Vedi [6. Cron Daily](#6-cron-daily) per la matrice completa dei pannelli.

---

## Licenza

LMD è sviluppato e supportato su base volontaria da Ryan MacDonald [[email protected]].

Linux Malware Detect (LMD) è distribuito sotto la GNU General Public License (GPL) v2
senza restrizioni sull'uso o sulla ridistribuzione. La dichiarazione di copyright e la GNU GPL
sono incluse nel file `COPYING.GPL`. Il credito deve essere attribuito per le opere derivate come
richiesto dalla GNU GPL.

---

## Supporto

Il repository sorgente di LMD si trova all'indirizzo: https://github.com/rfxn/linux-malware-detect

Bug, richieste di funzionalità e domande generali possono essere segnalati come problemi GitHub o inviati a [email protected].

La pagina ufficiale del progetto è all'indirizzo: https://www.rfxn.com/projects/linux-malware-detect/