### Passaggio 3: Esegui l'installer come root```bash
sudo ./qfeeds-installer.sh

**iptables+ipset backend:**```
┌──────────────────────────────────────────────────────────┐
│  ipset sets                                              │
│                                                          │
│  ┌─────────────────────────┐  ┌────────────────────────┐ │
│  │ qfeeds_blacklist_v4     │  │ qfeeds_blacklist_v4    │ │
│  │ (hash:ip)               │  │ _nets (hash:net)       │ │
│  │ maxelem 1000000         │  │ maxelem 65536          │ │
│  │                         │  │                        │ │
│  │ Individual IPs          │  │ CIDR ranges            │ │
│  └─────────────────────────┘  └────────────────────────┘ │
│                                                          │
│  ┌─────────────────────────┐                             │
│  │ qfeeds_whitelist_v4     │                             │
│  │ (hash:net)              │                             │
│  └─────────────────────────┘                             │
│                                                          │
│  iptables: INPUT/OUTPUT jump to a dedicated chain        │
│  (jump rule tagged -m comment "qfeeds"):                 │
│                                                          │
│  chain QFEEDS_INPUT (rebuilt each run, in order):        │
│    -m set --match-set whitelist_v4 src -j ACCEPT         │
│    -m set --match-set blacklist_v4 src -j DROP           │
│    -m set --match-set blacklist_v4_nets src -j DROP      │
│    (QFEEDS_OUTPUT mirrors this with dst, if enabled)     │
└──────────────────────────────────────────────────────────┘

### Sincronizzazione Completa vs Differenziale

| Modalità | Quando | Cosa fa |
|------|------|-------------|
| **Sincronizzazione completa** | Prima esecuzione, aggiornamento forzato, dopo un fallimento della sincronizzazione differenziale, quando il set locale ha perso la baseline (vuoto o molto più piccolo del previsto), o quando l'ultima sincronizzazione è più vecchia di `FULL_SYNC_MAX_AGE` (default 24h) | Recupera e convalida prima ogni feed, poi svuota e ricarica i set di blacklist. Il set viene svuotato solo dopo aver ottenuto dati validi, quindi un recupero fallito non ti lascia mai senza protezione |
| **Sincronizzazione differenziale** | Esecuzioni successive (solo feed `malware_ip`) con un set locale integro | Recupera solo le aggiunte (`+`) e le rimozioni (`-`) dall'ultimo pull |

La sincronizzazione differenziale è **per chiave API** — l'API tiene traccia del tuo ultimo pull riuscito e restituisce solo le modifiche successive. Se una sincronizzazione differenziale fallisce, lo script torna automaticamente a una sincronizzazione completa.

> **Auto-riparazione:** Gli aggiornamenti differenziali aggiornano solo il set esistente. Se quel set viene perso o troncato, ad esempio a causa di un riavvio in cui le regole del firewall non sono state mantenute, un flush manuale o una sincronizzazione parziale precedente, l'aggiornatore rileva la baseline mancante (il conteggio degli elementi live è 0 o molto inferiore all'ultimo conteggio registrato) e forza una ricostruzione completa invece di applicare le differenze su un set vuoto. Come ulteriore rete di sicurezza, forza anche una sincronizzazione completa periodica (ogni 24 ore per impostazione predefinita, tramite `FULL_SYNC_MAX_AGE`).

### Pianificazione Basata sulla Licenza

L'aggiornatore controlla l'API delle licenze Q-Feeds (`licenses.php`) prima di ogni esecuzione. Se il timestamp `next_update` della tua licenza non è stato ancora raggiunto, lo script termina anticipatamente senza effettuare chiamate API non necessarie. Il cron job viene eseguito frequentemente (default: ogni 20 minuti), ma gli aggiornamenti effettivi avvengono solo quando la tua licenza lo consente.

---

## ✅ Prerequisiti

Prima dell'installazione, assicurati di avere:

- [x] **Server Linux** con **nftables** o **iptables** (Debian, Ubuntu, CentOS, Fedora, Arch, Alpine)
- [x] **Accesso root** — il programma di installazione e l'aggiornatore devono essere eseguiti come root
- [x] **Token API Q-Feeds** — ottieni il tuo gratuito su [tip.qfeeds.com](https://tip.qfeeds.com/)
- [x] **Accesso a Internet** — il server deve poter raggiungere `api.qfeeds.com`

Il programma di installazione installerà automaticamente le dipendenze necessarie:
- **Backend nftables**: `nftables`, `curl`, `jq`, `util-linux`
- **Backend iptables**: `iptables`, `ipset`, `curl`, `jq`, `util-linux`

---

## 📝 Guida di Installazione Dettagliata

### 1. Ottieni il Tuo Token API

Visita [tip.qfeeds.com](https://tip.qfeeds.com/) per ottenere il tuo token API Q-Feeds gratuito.

### 2. Scarica ed Esegui```bash
git clone https://github.com/Q-Feeds/NFtables-IPtables-integration-script.git
cd NFtables-IPtables-integration-script
chmod +x qfeeds-installer.sh qfeeds-uninstaller.sh
sudo ./qfeeds-installer.sh

Il tuo token da [tip.qfeeds.com](https://tip.qfeeds.com/). Il programma di installazione rifiuta di proseguire se vuoto.

#### Tipo di Feed```
Enter feed type [default: malware_ip]:

Premi Invio per nessun limite (consigliato). Inserisci un numero per limitare la dimensione del feed.

#### Blocco direzionale```
Block INCOMING connections from malicious IPs? [Y/n]:
Block OUTGOING connections to malicious IPs? [y/N]:

Add your management IP(s) here to ensure you are never locked out, even if they appear in the feed. Whitelist rules are always checked **before** blacklist rules.

#### Programma Cron```
Enter cron schedule (e.g., '*/20 * * * *') [default: */20 * * * *]:

### iptables+ipset backend```bash
# List all Q-Feeds ipsets and their sizes
ipset list -t | grep -A4 qfeeds

# Count loaded IPv4 IPs
ipset list qfeeds_blacklist_v4 | tail -n +9 | wc -l

# Show loaded CIDR ranges
ipset list qfeeds_blacklist_v4_nets | tail -n +9 | head -20

# Show the qfeeds jump rule in INPUT, then the dedicated chain's block rules
iptables -L INPUT -n --line-numbers | grep qfeeds
iptables -L QFEEDS_INPUT -n
ip6tables -L QFEEDS_INPUT -n

---

## 🔍 Risoluzione dei problemi

### Generale

**L'installazione fallisce con "Unable to locate package"**
- Il programma di installazione rileva automaticamente la tua distribuzione (Debian/Ubuntu, CentOS/RHEL, Fedora, Arch, Alpine). Se il rilevamento fallisce, installa le dipendenze manualmente: `curl`, `jq`, `util-linux` (per `flock`), più `nftables` o `iptables`+`ipset`.

**I set sono vuoti dopo l'installazione**
- Controlla il log: `tail -50 /var/log/qfeeds_blocklist.log`
- Verifica che il tuo token API sia corretto
- Prova un aggiornamento forzato: `sudo QFEEDS_FORCE_UPDATE=1 /usr/local/bin/update_qfeeds_blocklist.sh`

**"Non è ancora il momento. Prossimo aggiornamento programmato per..."**
- L'updater rispetta la pianificazione della tua licenza. Questo messaggio significa che il cron è stato eseguito, ma la tua licenza non consente ancora un aggiornamento. È normale — la prossima esecuzione del cron controllerà di nuovo.
- Il programma di installazione Linux mantiene un indice locale `licenses.php` in cache e utilizza il `next_update` memorizzato come gate della pianificazione. Dopo un prelievo riuscito, aggiorna quell'indice locale per il ciclo successivo.

**Le regole non persistono dopo il riavvio**
- Se `netfilter-persistent` è installato, le regole vengono salvate automaticamente
- **nftables**: se `netfilter-persistent` è assente, l'updater ora scrive automaticamente l'intero ruleset in `/etc/nftables.conf` e abilita il servizio `nftables`; puoi comunque salvare manualmente con `nft list ruleset > /etc/nftables.conf`
- **iptables**: l'updater salva con `ipset save > /etc/ipset.conf` e `iptables-save`; puoi anche salvare manualmente
- Anche se la persistenza fallisce completamente, l'updater si auto-ripara: alla prossima esecuzione rileva il set vuoto dopo il riavvio e lo ricostruisce con una sincronizzazione completa

### Specifiche per nftables

**"Batch nft -f fallito. Ripiego all'esecuzione per comando..."**
- Questo è normale, specialmente su contenitori LXC dove il buffer netlink del kernel (`wmem_max`) è limitato. Il fallback per comando funziona correttamente ed è veloce (~10 secondi per oltre 400k IP).

**Errore di sintassi: "stringa inaspettata"**
- Assicurati di eseguire una versione recente di nftables. Lo script utilizza la sintassi `ip saddr`/`ip daddr` che richiede nftables 0.9+.

**"Errore: Impossibile elaborare la regola: Messaggio troppo lungo"**
- Questo è il limite del buffer netlink, tipico nei contenitori LXC. Lo script passa automaticamente all'esecuzione per comando. Se vedi questo nel log insieme a un caricamento riuscito, funziona come previsto.

### Specifiche per iptables+ipset

**"ipset restore fallito"**
- Verifica che `ipset` sia installato: `command -v ipset`
- Controlla il log per errori specifici: `grep -i "error" /var/log/qfeeds_blocklist.log`
- Assicurati che il modulo ipset sia caricato: `lsmod | grep ip_set`

**Le regole iptables non vengono visualizzate**
- Le regole di blocco risiedono nelle catene dedicate `QFEEDS_INPUT` / `QFEEDS_OUTPUT`; `INPUT`/`OUTPUT` contengono solo un salto `-j QFEEDS_INPUT` taggato con il commento `qfeeds`
- Verifica con: `iptables -L INPUT -n | grep qfeeds` (il salto) e `iptables -L QFEEDS_INPUT -n` (le regole di blocco)
- La regola di salto utilizza `-m comment --comment "qfeeds"` per l'identificazione
- Assicurati che il modulo `xt_set` sia caricato: `modprobe xt_set`

**"ipset create ... fallito"**
- Su kernel molto vecchi, i tipi `hash:ip` o `hash:net` potrebbero non essere disponibili. Aggiorna il kernel o installa `ipset` da un repository più recente.

---

## 🗑️ Disinstallazione```bash
sudo ./qfeeds-uninstaller.sh