@liberstudio/cloudflare-list 2.3.9 → 2.4.1

package/README.md

@@ -1,183 +1,184 @@
-# @liberstudio/cloudflare-list
-
-Modulo NestJS per il rilevamento e blocco automatico di attacchi tramite Cloudflare IP List.
-
-Ogni richiesta che produce un `404` viene considerata sospetta (tipicamente bot, scanner, enumeratori). L'IP viene risolto tramite ASN lookup per ottenere l'intero range di subnet e bloccarlo direttamente sulla lista Cloudflare WAF. Se il lookup fallisce, viene bloccato il singolo IP.
-
-## Come funziona
-
-```
-Request → 404 rilevato dal middleware
-  └─ IP estratto (cf-connecting-ip / x-real-ip / x-forwarded-for)
-       └─ throttle 5s per IP
-            └─ log su file (se path non è silentPath)
-                 └─ allowedIps? → skip (log only)
-                      └─ IP Cloudflare? → skip (log only)
-                           └─ ASN lookup su api.hackertarget.com
-                                ├─ range trovato → blocca intera subnet su Cloudflare
-                                └─ fallback      → blocca singolo IP /32 o /128
-```
-
-### Filtraggio automatico
-
-Il modulo ignora automaticamente:
-- IP nella whitelist `allowedIps` (configurazione statica)
-- IP appartenenti ai range ufficiali Cloudflare (scaricati e cachati 24h)
-- IP privati (10.x, 192.168.x, 172.16–31.x)
-- Loopback (127.0.0.1, ::1)
-- IPv4-mapped IPv6 (::ffff:x.x.x.x → convertiti in IPv4)
-
-### Gestione errori e log
-
-- `AllExceptionsFilter` globale cattura tutte le eccezioni non gestite e le logga a console con IP, metodo, path e status code
-- Con `verbose: true` il log include anche body, query, params e stack trace
-
----
-
-## Prima di iniziare su Cloudflare
-
-1. Creare un account Cloudflare
-2. Scegliere il dominio da utilizzare
-3. **Manage Account > Configuration > Lists > Create List** (tipo: IP)
-4. **Account API tokens > Create Token > Create Custom Token**
-   - Permission: `Account > Account WAF > Edit`
-   - Permission: `Account > Account Filter Lists > Edit`
-5. **Security > WAF > Custom Rules > Create Rule**
-   - Field: `IP Source Address` — `is in` — scegli la lista creata
-   - Action: `Block`
-6. Salvare la regola
-
----
-
-## Installazione
-
-```bash
-npm install @liberstudio/cloudflare-list
-```
-
----
-
-## Configurazione
-
-### Statica (`forRoot`)
-
-```typescript
-import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
-
-@Module({
-  imports: [
-    CloudflareAttacksModule.forRoot({
-      accountId: "abc123",
-      listId:    "def456",
-      apiToken:  "your-cloudflare-api-token",
-      comment:   "Blocked by liberstudio/cloudflare-list",
-      logPath:   "/var/log/nestjs-attacks.log",
-      allowedIps:    ["1.2.3.4", "10.0.0.0/8"],
-      excludedPaths: ["/api/health", "/api/webhook"],
-      silentPaths:   ["/auth/me", "/auth/refresh"],
-      verbose: false,
-      whatsappNotify: { phone: "393331234567" },
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-### Asincrona (`forRootAsync`) con `ConfigModule`
-
-```typescript
-import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
-
-@Module({
-  imports: [
-    CloudflareAttacksModule.forRootAsync({
-      imports: [ConfigModule],
-      inject:  [ConfigService],
-      useFactory: (config: ConfigService) => ({
-        apiToken:  config.getOrThrow<string>("CLOUDFLARE_API_TOKEN"),
-        accountId: config.getOrThrow<string>("CLOUDFLARE_ACCOUNT_ID"),
-        listId:    config.getOrThrow<string>("CLOUDFLARE_LIST_ID"),
-        comment:   config.get<string>("CLOUDFLARE_LIST_COMMENT") || "Blocked",
-        logPath:   config.get<string>("CLOUDFLARE_LIST_LOG_PATH") || "/var/log/nestjs-attacks.log",
-        allowedIps:    ["1.2.3.4", "10.0.0.0/8"],
-        excludedPaths: ["/api/health", "/api/webhook", /^\/api\/public\/.*/],
-        silentPaths:   ["/auth/me", "/auth/refresh"],
-        verbose: false,
-        whatsappNotify: {
-          phone: config.getOrThrow<string>("WA_NOTIFY_PHONE"),
-        },
-      }),
-    }),
-  ],
-})
-export class AppModule {}
-```
-
----
-
-## Opzioni di configurazione
-
-| Opzione | Tipo | Obbligatorio | Descrizione |
-|---|---|---|---|
-| `apiToken` | `string` | si | Token API Cloudflare |
-| `accountId` | `string` | si | ID account Cloudflare |
-| `listId` | `string` | si | ID della IP List Cloudflare |
-| `comment` | `string` | si | Commento aggiunto ad ogni IP bloccato |
-| `logPath` | `string` | si | Percorso del file di log degli attacchi |
-| `allowedIps` | `string[]` | no | IP o CIDR mai bloccati (whitelist, supporta IPv4 e IPv6) |
-| `excludedPaths` | `(string \| RegExp)[]` | no | Path esclusi da ogni rilevamento e log |
-| `silentPaths` | `(string \| RegExp)[]` | no | Path bloccati su Cloudflare ma senza log su file |
-| `verbose` | `boolean` | no | Se `true`, il log include body, query, params e stack |
-| `whatsappNotify` | `{ phone: string }` | no | Invia una notifica WhatsApp quando un IP viene bannato |
-
-### `whatsappNotify` — notifiche ban su WhatsApp
-
-Quando configurato, invia un messaggio WhatsApp ad un numero specifico ogni volta che un IP viene bloccato su Cloudflare. Richiede le variabili d'ambiente `WA_URL`, `WA_USER`, `WA_PASSWORD` e `CLOUDFLARE_WA_DEVICE_ID` già presenti nel progetto (lette automaticamente da `process.env`).
-
-```typescript
-whatsappNotify: {
-  phone: "393331234567", // numero con prefisso internazionale, senza +
-}
-```
-
-Il messaggio inviato sarà:
-```
-🚨 IP bannato su Cloudflare
-IP: 1.2.3.4
-Subnet bloccata: 1.2.0.0/16
-```
-
-Variabili d'ambiente richieste (lette automaticamente da `process.env`):
-```env
-WA_URL=https://messaggistica.liberdesign.eu
-WA_USER=your-user
-WA_PASSWORD=your-password
-CLOUDFLARE_WA_DEVICE_ID=your-device-id
-WA_NOTIFY_PHONE=393331234567
-```
-
-### `allowedIps` — whitelist server
-
-Lista di IP o subnet CIDR che non vengono mai bloccati, indipendentemente dal comportamento. Utile per i propri server, proxy interni, CDN proprietarie. Supporta IPv4, CIDR IPv4, IPv6 e CIDR IPv6:
-
-```typescript
-allowedIps: [
-  "1.2.3.4",           // IP singolo IPv4
-  "10.0.0.0/8",        // subnet IPv4
-  "2001:db8::1",       // IP singolo IPv6
-  "2001:db8::/32",     // subnet IPv6
-]
-```
-
-> I range ufficiali Cloudflare sono esclusi automaticamente senza bisogno di aggiungerli qui.
-
-### `excludedPaths` vs `silentPaths`
-
-- **`excludedPaths`**: il path viene ignorato completamente — nessun log, nessun blocco. Usato per path infrastrutturali (`/health`, `/webhook`).
-- **`silentPaths`**: il path viene bloccato su Cloudflare ma non viene scritto sul file di log. Usato per path che generano 404 legittimi frequenti (`/auth/me`, `/auth/refresh`).
-
----
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+# @liberstudio/cloudflare-list
+
+Modulo NestJS per il rilevamento e blocco automatico di attacchi tramite Cloudflare IP List.
+
+Ogni richiesta che produce un `404` viene considerata sospetta (tipicamente bot, scanner, enumeratori). L'IP viene risolto tramite ASN lookup per ottenere l'intero range di subnet e bloccarlo direttamente sulla lista Cloudflare WAF. Se il lookup fallisce, viene bloccato il singolo IP.
+
+## Come funziona
+
+```
+Request → 404 rilevato dal middleware
+  └─ IP estratto (cf-connecting-ip / x-real-ip / x-forwarded-for)
+       └─ throttle 5s per IP
+            └─ log su file (se path non è silentPath)
+                 └─ allowedIps? → skip (log only)
+                      └─ IP Cloudflare? → skip (log only)
+                           └─ ASN lookup su api.hackertarget.com
+                                ├─ range trovato → blocca intera subnet su Cloudflare
+                                └─ fallback      → blocca singolo IP /32 o /128
+```
+
+### Filtraggio automatico
+
+Il modulo ignora automaticamente:
+- IP nella whitelist `allowedIps` (configurazione statica)
+- IP appartenenti ai range ufficiali Cloudflare (scaricati e cachati 24h)
+- IP privati (10.x, 192.168.x, 172.16–31.x)
+- Loopback (127.0.0.1, ::1)
+- IPv4-mapped IPv6 (::ffff:x.x.x.x → convertiti in IPv4)
+
+### Gestione errori e log
+
+- `AllExceptionsFilter` globale cattura tutte le eccezioni non gestite e le logga a console con IP, metodo, path e status code
+- Con `verbose: true` il log include anche body, query, params e stack trace
+
+---
+
+## Prima di iniziare su Cloudflare
+
+1. Creare un account Cloudflare
+2. Scegliere il dominio da utilizzare
+3. **Manage Account > Configuration > Lists > Create List** (tipo: IP)
+4. **Account API tokens > Create Token > Create Custom Token**
+   - Permission: `Account > Account WAF > Edit`
+   - Permission: `Account > Account Filter Lists > Edit`
+5. **Security > WAF > Custom Rules > Create Rule**
+   - Field: `IP Source Address` — `is in` — scegli la lista creata
+   - Action: `Block`
+6. Salvare la regola
+
+---
+
+## Installazione
+
+```bash
+npm install @liberstudio/cloudflare-list
+```
+
+---
+
+## Configurazione
+
+### Statica (`forRoot`)
+
+```typescript
+import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
+
+@Module({
+  imports: [
+    CloudflareAttacksModule.forRoot({
+      accountId: "abc123",
+      listId:    "def456",
+      apiToken:  "your-cloudflare-api-token",
+      comment:   "Blocked by liberstudio/cloudflare-list",
+      logPath:   "/var/log/nestjs-attacks.log",
+      allowedIps:    ["1.2.3.4", "10.0.0.0/8"],
+      excludedPaths: ["/api/health", "/api/webhook"],
+      silentPaths:   ["/auth/me", "/auth/refresh"],
+      verbose: false,
+      whatsappNotify: { phone: "393331234567" },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Asincrona (`forRootAsync`) con `ConfigModule`
+
+```typescript
+import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
+
+@Module({
+  imports: [
+    CloudflareAttacksModule.forRootAsync({
+      imports: [ConfigModule],
+      inject:  [ConfigService],
+      useFactory: (config: ConfigService) => ({
+        apiToken:  config.getOrThrow<string>("CLOUDFLARE_API_TOKEN"),
+        accountId: config.getOrThrow<string>("CLOUDFLARE_ACCOUNT_ID"),
+        listId:    config.getOrThrow<string>("CLOUDFLARE_LIST_ID"),
+        comment:   config.get<string>("CLOUDFLARE_LIST_COMMENT") || "Blocked",
+        logPath:   config.get<string>("CLOUDFLARE_LIST_LOG_PATH") || "/var/log/nestjs-attacks.log",
+        allowedIps:    ["1.2.3.4", "10.0.0.0/8"],
+        excludedPaths: ["/api/health", "/api/webhook", /^\/api\/public\/.*/],
+        silentPaths:   ["/auth/me", "/auth/refresh"],
+        verbose: false,
+        whatsappNotify: {
+          phone: config.getOrThrow<string>("WA_NOTIFY_PHONE"),
+        },
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+---
+
+## Opzioni di configurazione
+
+| Opzione | Tipo | Obbligatorio | Descrizione |
+|---|---|---|---|
+| `apiToken` | `string` | si | Token API Cloudflare |
+| `accountId` | `string` | si | ID account Cloudflare |
+| `listId` | `string` | si | ID della IP List Cloudflare |
+| `comment` | `string` | si | Commento aggiunto ad ogni IP bloccato |
+| `logPath` | `string` | si | Percorso del file di log degli attacchi |
+| `allowedIps` | `string[]` | no | IP o CIDR mai bloccati (whitelist, supporta IPv4 e IPv6) |
+| `excludedPaths` | `(string \| RegExp)[]` | no | Path esclusi da ogni rilevamento e log |
+| `silentPaths` | `(string \| RegExp)[]` | no | Path bloccati su Cloudflare ma senza log su file |
+| `verbose` | `boolean` | no | Se `true`, il log include body, query, params e stack |
+| `whatsappNotify` | `{ phone: string }` | no | Invia una notifica WhatsApp quando un IP viene bannato |
+
+### `whatsappNotify` — notifiche ban su WhatsApp
+
+Quando configurato, invia un messaggio WhatsApp ad un numero specifico ogni volta che un IP viene bloccato su Cloudflare. Richiede le variabili d'ambiente `WA_URL`, `WA_USER`, `WA_PASSWORD` e `CLOUDFLARE_WA_DEVICE_ID` già presenti nel progetto (lette automaticamente da `process.env`).
+
+```typescript
+whatsappNotify: {
+  phone: "393331234567", // numero con prefisso internazionale, senza +
+}
+```
+
+Il messaggio inviato sarà:
+```
+🚨 IP bannato su Cloudflare
+Provenienza: Blocked by liberstudio/cloudflare-list
+IP: 1.2.3.4
+Subnet bloccata: 1.2.0.0/16
+```
+
+Variabili d'ambiente richieste (lette automaticamente da `process.env`):
+```env
+WA_URL=https://messaggistica.liberdesign.eu
+WA_USER=your-user
+WA_PASSWORD=your-password
+CLOUDFLARE_WA_DEVICE_ID=your-device-id
+WA_NOTIFY_PHONE=393331234567
+```
+
+### `allowedIps` — whitelist server
+
+Lista di IP o subnet CIDR che non vengono mai bloccati, indipendentemente dal comportamento. Utile per i propri server, proxy interni, CDN proprietarie. Supporta IPv4, CIDR IPv4, IPv6 e CIDR IPv6:
+
+```typescript
+allowedIps: [
+  "1.2.3.4",           // IP singolo IPv4
+  "10.0.0.0/8",        // subnet IPv4
+  "2001:db8::1",       // IP singolo IPv6
+  "2001:db8::/32",     // subnet IPv6
+]
+```
+
+> I range ufficiali Cloudflare sono esclusi automaticamente senza bisogno di aggiungerli qui.
+
+### `excludedPaths` vs `silentPaths`
+
+- **`excludedPaths`**: il path viene ignorato completamente — nessun log, nessun blocco. Usato per path infrastrutturali (`/health`, `/webhook`).
+- **`silentPaths`**: il path viene bloccato su Cloudflare ma non viene scritto sul file di log. Usato per path che generano 404 legittimi frequenti (`/auth/me`, `/auth/refresh`).
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/attacks.service.js

@@ -39,6 +39,10 @@ let AttacksService = class AttacksService {
             this.logger.log(`IP ${rawIp} appartiene al range Cloudflare — ban saltato`);
             return null;
         }
+        if (await (0, utils_1.isGoogleBotIp)(rawIp)) {
+            this.logger.log(`IP ${rawIp} è un crawler Google — ban saltato`);
+            return null;
+        }
         const asnRange = await this.lookupAsnRange(rawIp);
         if (asnRange) {
             this.logger.error(`ASN range trovato per ${rawIp}: ${asnRange} — blocco intera subnet`);
@@ -66,7 +70,7 @@ let AttacksService = class AttacksService {
             return;
         }
         const auth = Buffer.from(`${user}:${password}`).toString("base64");
-        const message = `🚨 IP bannato su Cloudflare\nIP: ${rawIp}\nSubnet bloccata: ${cidr}`;
+        const message = `🚨 IP bannato su Cloudflare\nProvenienza: ${this.options.comment}\nIP: ${rawIp}\nSubnet bloccata: ${cidr}`;
         (0, rxjs_1.firstValueFrom)(this.httpService.post(`${url}/send/message`, { phone: wa.phone, message }, { headers: { Authorization: `Basic ${auth}`, "X-Device-Id": deviceId } })).catch((err) => {
             const msg = err instanceof Error ? err.message : "Errore sconosciuto";
             this.logger.warn(`Notifica WhatsApp fallita: ${msg}`);

package/dist/utils/cidr.util.d.ts

@@ -0,0 +1,10 @@
+/** Rimuove il suffisso CIDR, fa trim e srotola gli IPv4-mapped IPv6 (`::ffff:`). */
+export declare function purifyIp(ip: string): string;
+export declare function ipv4ToInt(ip: string): number;
+export declare function ipv6ToBigInt(ip: string): bigint;
+export declare function isInCidrV4(ip: string, cidr: string): boolean;
+export declare function isInCidrV6(ip: string, cidr: string): boolean;
+/** Verifica se un IP "puro" appartiene a uno qualsiasi dei CIDR della sua versione. */
+export declare function isIpInAnyCidr(pureIp: string, cidrs: string[], version: 4 | 6): boolean;
+/** Ritorna la versione IP (4 | 6) di un valore già "purificato", oppure null. */
+export declare function ipVersion(pureIp: string): 4 | 6 | null;

package/dist/utils/cidr.util.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purifyIp = purifyIp;
+exports.ipv4ToInt = ipv4ToInt;
+exports.ipv6ToBigInt = ipv6ToBigInt;
+exports.isInCidrV4 = isInCidrV4;
+exports.isInCidrV6 = isInCidrV6;
+exports.isIpInAnyCidr = isIpInAnyCidr;
+exports.ipVersion = ipVersion;
+const net_1 = require("net");
+/** Rimuove il suffisso CIDR, fa trim e srotola gli IPv4-mapped IPv6 (`::ffff:`). */
+function purifyIp(ip) {
+    let pure = ip.includes("/") ? ip.split("/")[0] : ip;
+    pure = pure.trim();
+    if (pure.startsWith("::ffff:"))
+        pure = pure.slice("::ffff:".length);
+    return pure;
+}
+function ipv4ToInt(ip) {
+    return ip.split(".").reduce((acc, oct) => (acc << 8) + Number(oct), 0) >>> 0;
+}
+function ipv6ToBigInt(ip) {
+    const [headStr, tailStr] = ip.includes("::") ? ip.split("::") : [ip, ""];
+    const head = headStr ? headStr.split(":") : [];
+    const tail = tailStr ? tailStr.split(":") : [];
+    const missing = 8 - head.length - tail.length;
+    const groups = [...head, ...Array(missing).fill("0"), ...tail];
+    return groups.reduce((acc, g) => (acc << 16n) + BigInt(parseInt(g || "0", 16)), 0n);
+}
+function isInCidrV4(ip, cidr) {
+    const [range, bitsStr] = cidr.split("/");
+    const bits = bitsStr === undefined ? 32 : Number(bitsStr);
+    if (bits === 0)
+        return true;
+    const mask = (0xffffffff << (32 - bits)) >>> 0;
+    return (ipv4ToInt(ip) & mask) === (ipv4ToInt(range) & mask);
+}
+function isInCidrV6(ip, cidr) {
+    const [range, bitsStr] = cidr.split("/");
+    const prefix = bitsStr === undefined ? 128 : Number(bitsStr);
+    if (prefix === 0)
+        return true;
+    const mask = ((1n << 128n) - 1n) ^ ((1n << BigInt(128 - prefix)) - 1n);
+    return (ipv6ToBigInt(ip) & mask) === (ipv6ToBigInt(range) & mask);
+}
+/** Verifica se un IP "puro" appartiene a uno qualsiasi dei CIDR della sua versione. */
+function isIpInAnyCidr(pureIp, cidrs, version) {
+    return version === 4
+        ? cidrs.some((cidr) => isInCidrV4(pureIp, cidr))
+        : cidrs.some((cidr) => isInCidrV6(pureIp, cidr));
+}
+/** Ritorna la versione IP (4 | 6) di un valore già "purificato", oppure null. */
+function ipVersion(pureIp) {
+    const version = (0, net_1.isIP)(pureIp);
+    return version === 0 ? null : version;
+}

package/dist/utils/cloudflare-ips.util.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAllowedIp = isAllowedIp;
 exports.isCloudflareIp = isCloudflareIp;
 const axios_1 = __importDefault(require("axios"));
-const net_1 = require("net");
+const cidr_util_1 = require("./cidr.util");
 const CF_IPS_V4_URL = "https://www.cloudflare.com/ips-v4/";
 const CF_IPS_V6_URL = "https://www.cloudflare.com/ips-v6/";
 const TTL_MS = 24 * 60 * 60 * 1000;
@@ -34,71 +34,30 @@ async function loadCloudflareIps() {
     });
     return inFlight;
 }
-function ipv4ToInt(ip) {
-    return ip.split(".").reduce((acc, oct) => (acc << 8) + Number(oct), 0) >>> 0;
-}
-function ipv6ToBigInt(ip) {
-    const [headStr, tailStr] = ip.includes("::") ? ip.split("::") : [ip, ""];
-    const head = headStr ? headStr.split(":") : [];
-    const tail = tailStr ? tailStr.split(":") : [];
-    const missing = 8 - head.length - tail.length;
-    const groups = [...head, ...Array(missing).fill("0"), ...tail];
-    return groups.reduce((acc, g) => (acc << 16n) + BigInt(parseInt(g || "0", 16)), 0n);
-}
-function isInCidrV4(ip, cidr) {
-    const [range, bitsStr] = cidr.split("/");
-    const bits = bitsStr === undefined ? 32 : Number(bitsStr);
-    if (bits === 0)
-        return true;
-    const mask = (0xffffffff << (32 - bits)) >>> 0;
-    return (ipv4ToInt(ip) & mask) === (ipv4ToInt(range) & mask);
-}
-function isInCidrV6(ip, cidr) {
-    const [range, bitsStr] = cidr.split("/");
-    const prefix = bitsStr === undefined ? 128 : Number(bitsStr);
-    if (prefix === 0)
-        return true;
-    const mask = ((1n << 128n) - 1n) ^ ((1n << BigInt(128 - prefix)) - 1n);
-    return (ipv6ToBigInt(ip) & mask) === (ipv6ToBigInt(range) & mask);
-}
 function isAllowedIp(ip, allowedIps) {
     if (!ip || !allowedIps.length)
         return false;
-    let pure = ip.includes("/") ? ip.split("/")[0] : ip;
-    pure = pure.trim();
-    if (pure.startsWith("::ffff:"))
-        pure = pure.slice("::ffff:".length);
-    const version = (0, net_1.isIP)(pure);
+    const pure = (0, cidr_util_1.purifyIp)(ip);
+    const version = (0, cidr_util_1.ipVersion)(pure);
     if (!version)
         return false;
     return allowedIps.some((entry) => {
-        let entryPure = entry.includes("/") ? entry.split("/")[0] : entry;
-        entryPure = entryPure.trim();
-        if (entryPure.startsWith("::ffff:"))
-            entryPure = entryPure.slice("::ffff:".length);
-        const entryVersion = (0, net_1.isIP)(entryPure);
+        const entryVersion = (0, cidr_util_1.ipVersion)((0, cidr_util_1.purifyIp)(entry));
         if (!entryVersion || entryVersion !== version)
             return false;
-        return version === 4
-            ? isInCidrV4(pure, entry)
-            : isInCidrV6(pure, entry);
+        return (0, cidr_util_1.isIpInAnyCidr)(pure, [entry], version);
     });
 }
 async function isCloudflareIp(ip) {
     if (!ip)
         return false;
-    let pure = ip.includes("/") ? ip.split("/")[0] : ip;
-    pure = pure.trim();
-    if (pure.startsWith("::ffff:"))
-        pure = pure.slice("::ffff:".length);
-    const version = (0, net_1.isIP)(pure);
+    const pure = (0, cidr_util_1.purifyIp)(ip);
+    const version = (0, cidr_util_1.ipVersion)(pure);
     if (!version)
         return false;
     try {
         const { v4, v6 } = await loadCloudflareIps();
-        return version === 4
-            ? v4.some((cidr) => isInCidrV4(pure, cidr))
-            : v6.some((cidr) => isInCidrV6(pure, cidr));
+        return (0, cidr_util_1.isIpInAnyCidr)(pure, version === 4 ? v4 : v6, version);
     }
     catch {
         return false;

package/dist/utils/googlebot.util.d.ts

@@ -0,0 +1,11 @@
+/**
+ * True se l'IP appartiene ai crawler Google (Googlebot, special crawlers, fetcher).
+ *
+ * Strategia hybrid:
+ *  1. match veloce sulle liste IP ufficiali (cache 24h, auto-aggiornate);
+ *  2. fallback reverse DNS anti-spoofing se non presente nelle liste.
+ *
+ * Fail-open: se né le liste né il DNS riescono a verificare, ritorna `true`
+ * (non bannare) per non rischiare di bloccare Googlebot durante un disservizio.
+ */
+export declare function isGoogleBotIp(ip: string): Promise<boolean>;

package/dist/utils/googlebot.util.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGoogleBotIp = isGoogleBotIp;
+const axios_1 = __importDefault(require("axios"));
+const dns_1 = require("dns");
+const cidr_util_1 = require("./cidr.util");
+// Liste IP ufficiali pubblicate (e aggiornate) da Google.
+const GOOGLE_IP_LIST_URLS = [
+    "https://developers.google.com/static/search/apis/ipranges/googlebot.json",
+    "https://developers.google.com/static/search/apis/ipranges/special-crawlers.json",
+    "https://developers.google.com/static/search/apis/ipranges/user-triggered-fetchers.json",
+];
+// Domini dei crawler verificati da Google (per il fallback reverse DNS).
+const GOOGLE_HOSTS = [".googlebot.com", ".google.com", ".googleusercontent.com"];
+const TTL_MS = 24 * 60 * 60 * 1000;
+let cache = null;
+let inFlight = null;
+async function loadGoogleIps() {
+    if (cache && Date.now() < cache.expiresAt)
+        return cache;
+    if (inFlight)
+        return inFlight;
+    inFlight = (async () => {
+        const responses = await Promise.all(GOOGLE_IP_LIST_URLS.map((url) => axios_1.default.get(url)));
+        const v4 = [];
+        const v6 = [];
+        for (const res of responses) {
+            for (const prefix of res.data?.prefixes ?? []) {
+                if (prefix.ipv4Prefix)
+                    v4.push(prefix.ipv4Prefix);
+                if (prefix.ipv6Prefix)
+                    v6.push(prefix.ipv6Prefix);
+            }
+        }
+        cache = { v4, v6, expiresAt: Date.now() + TTL_MS };
+        return cache;
+    })().finally(() => {
+        inFlight = null;
+    });
+    return inFlight;
+}
+/**
+ * Verifica anti-spoofing via reverse + forward DNS (metodo raccomandato da Google).
+ * Ritorna `true`/`false` se determinabile, `null` se la risoluzione DNS fallisce.
+ */
+async function verifyByReverseDns(pureIp, version) {
+    try {
+        const hostnames = await dns_1.promises.reverse(pureIp);
+        const host = hostnames.find((h) => GOOGLE_HOSTS.some((d) => h.endsWith(d)));
+        if (!host)
+            return false; // reverse DNS risolto ma non è un dominio Google
+        const resolved = version === 4 ? await dns_1.promises.resolve4(host) : await dns_1.promises.resolve6(host);
+        return resolved.some((addr) => (0, cidr_util_1.purifyIp)(addr) === pureIp);
+    }
+    catch {
+        return null; // nessun PTR / errore DNS: non determinabile
+    }
+}
+/**
+ * True se l'IP appartiene ai crawler Google (Googlebot, special crawlers, fetcher).
+ *
+ * Strategia hybrid:
+ *  1. match veloce sulle liste IP ufficiali (cache 24h, auto-aggiornate);
+ *  2. fallback reverse DNS anti-spoofing se non presente nelle liste.
+ *
+ * Fail-open: se né le liste né il DNS riescono a verificare, ritorna `true`
+ * (non bannare) per non rischiare di bloccare Googlebot durante un disservizio.
+ */
+async function isGoogleBotIp(ip) {
+    if (!ip)
+        return false;
+    const pure = (0, cidr_util_1.purifyIp)(ip);
+    const version = (0, cidr_util_1.ipVersion)(pure);
+    if (!version)
+        return false;
+    let listAvailable = false;
+    try {
+        const { v4, v6 } = await loadGoogleIps();
+        listAvailable = true;
+        if ((0, cidr_util_1.isIpInAnyCidr)(pure, version === 4 ? v4 : v6, version))
+            return true;
+    }
+    catch {
+        listAvailable = false;
+    }
+    const dnsResult = await verifyByReverseDns(pure, version);
+    if (dnsResult !== null)
+        return dnsResult;
+    // DNS non determinabile: se la lista era disponibile e l'IP non c'era → non è Google;
+    // se nemmeno la lista era raggiungibile → fail-open.
+    return !listAvailable;
+}

package/dist/utils/index.d.ts

@@ -1,4 +1,6 @@
+export * from './cidr.util';
 export * from './cloudflare.constants';
 export * from './cloudflare-ips.util';
 export * from './get-client-ip.util';
+export * from './googlebot.util';
 export * from './options.validator';

package/dist/utils/index.js

@@ -14,7 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cidr.util"), exports);
 __exportStar(require("./cloudflare.constants"), exports);
 __exportStar(require("./cloudflare-ips.util"), exports);
 __exportStar(require("./get-client-ip.util"), exports);
+__exportStar(require("./googlebot.util"), exports);
 __exportStar(require("./options.validator"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liberstudio/cloudflare-list",
-  "version": "2.3.9",
+  "version": "2.4.1",
   "description": "Modulo NestJS per gestione IP List Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,14 +32,17 @@
     "rxjs": ">=7.0.0"
   },
   "devDependencies": {
-    "@nestjs/axios": "^4.0.0",
-    "@nestjs/common": "^11.0.0",
-    "@nestjs/core": "^11.1.14",
+    "@nestjs/axios": "^4.0.1",
+    "@nestjs/common": "^11.1.26",
+    "@nestjs/core": "^11.1.26",
     "@types/express": "^5.0.6",
-    "@types/node": "^20.9.0",
-    "axios": "^1.0.0",
-    "rxjs": "^7.8.0",
+    "@types/node": "^20.19.43",
+    "axios": "^1.18.0",
+    "rxjs": "^7.8.2",
     "simple-git-hooks": "^2.13.1",
     "typescript": "^5.0.0"
+  },
+  "allowScripts": {
+    "simple-git-hooks@2.13.1": true
   }
 }