@liberstudio/cloudflare-list 2.3.4 → 2.3.8

package/README.md

@@ -11,14 +11,18 @@ 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)
-                 └─ ASN lookup su api.hackertarget.com
-                      ├─ range trovato → blocca intera subnet su Cloudflare
-                      └─ fallback      → blocca singolo IP /32 o /128
+                 └─ 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)
@@ -68,9 +72,11 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
       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" },
     }),
   ],
 })
@@ -93,9 +99,13 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
         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"),
+        },
       }),
     }),
   ],
@@ -114,9 +124,52 @@ export class AppModule {}
 | `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 `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
+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`
 

package/dist/attacks.service.d.ts

@@ -8,6 +8,7 @@ export declare class AttacksService {
     private readonly ASN_LOOKUP_URL;
     constructor(httpService: HttpService, options: CloudflareAttacksOptions);
     blockIp(rawIp: string): Promise<CloudflareResponse | null>;
+    private sendWhatsappNotification;
     private lookupAsnRange;
     updateIpList(cidr: string): Promise<CloudflareResponse>;
 }

package/dist/attacks.service.js

@@ -31,19 +31,46 @@ let AttacksService = class AttacksService {
         this.ASN_LOOKUP_URL = `https://api.hackertarget.com/aslookup`;
     }
     async blockIp(rawIp) {
+        if ((0, utils_1.isAllowedIp)(rawIp, this.options.allowedIps ?? [])) {
+            this.logger.log(`IP ${rawIp} in whitelist — ban saltato`);
+            return null;
+        }
         if (await (0, utils_1.isCloudflareIp)(rawIp)) {
             this.logger.log(`IP ${rawIp} appartiene al range Cloudflare — ban saltato`);
             return null;
         }
         const asnRange = await this.lookupAsnRange(rawIp);
         if (asnRange) {
-            this.logger.log(`ASN range trovato per ${rawIp}: ${asnRange} — blocco intera subnet`);
-            return this.updateIpList(asnRange);
+            this.logger.error(`ASN range trovato per ${rawIp}: ${asnRange} — blocco intera subnet`);
+            const result = await this.updateIpList(asnRange);
+            this.sendWhatsappNotification(rawIp, asnRange);
+            return result;
         }
         const cidr = (0, utils_1.normalizeIp)(rawIp);
         if (!cidr)
             throw new Error(`IP non valido: ${rawIp}`);
-        return this.updateIpList(cidr);
+        const result = await this.updateIpList(cidr);
+        this.sendWhatsappNotification(rawIp, cidr);
+        return result;
+    }
+    sendWhatsappNotification(rawIp, cidr) {
+        const wa = this.options.whatsappNotify;
+        if (!wa)
+            return;
+        const url = process.env["WA_URL"];
+        const user = process.env["WA_USER"];
+        const password = process.env["WA_PASSWORD"];
+        const deviceId = process.env["WA_DEVICE_ID"];
+        if (!url || !user || !password || !deviceId) {
+            this.logger.warn("Notifica WhatsApp saltata: WA_URL, WA_USER, WA_PASSWORD o WA_DEVICE_ID mancanti");
+            return;
+        }
+        const auth = Buffer.from(`${user}:${password}`).toString("base64");
+        const message = `🚨 IP bannato su Cloudflare\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}`);
+        });
     }
     async lookupAsnRange(ip) {
         try {
@@ -57,7 +84,7 @@ let AttacksService = class AttacksService {
     async updateIpList(cidr) {
         const { accountId, listId, apiToken, comment } = this.options;
         const url = `${this.API_URL}/${accountId}/rules/lists/${listId}/items`;
-        this.logger.log(`Aggiungo ${cidr} alla lista Cloudflare`);
+        this.logger.error(`Aggiungo ${cidr} alla lista Cloudflare`);
         const body = [{ ip: cidr, comment }];
         try {
             const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(url, body, {

package/dist/interfaces/cloudflare-attacks.interface.d.ts

@@ -1,12 +1,17 @@
+export interface WhatsappNotifyOptions {
+    phone: string;
+}
 export interface CloudflareAttacksOptions {
     apiToken: string;
     accountId: string;
     listId: string;
     comment: string;
     logPath: string;
+    allowedIps?: string[];
     excludedPaths?: (string | RegExp)[];
     silentPaths?: (string | RegExp)[];
     verbose?: boolean;
+    whatsappNotify?: WhatsappNotifyOptions;
 }
 export interface CloudflareAttacksAsyncOptions {
     imports?: any[];

package/dist/utils/cloudflare-ips.util.d.ts

@@ -1 +1,2 @@
+export declare function isAllowedIp(ip: string, allowedIps: string[]): boolean;
 export declare function isCloudflareIp(ip: string): Promise<boolean>;

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowedIp = isAllowedIp;
 exports.isCloudflareIp = isCloudflareIp;
 const axios_1 = __importDefault(require("axios"));
 const net_1 = require("net");
@@ -60,6 +61,29 @@ function isInCidrV6(ip, cidr) {
     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);
+    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);
+        if (!entryVersion || entryVersion !== version)
+            return false;
+        return version === 4
+            ? isInCidrV4(pure, entry)
+            : isInCidrV6(pure, entry);
+    });
+}
 async function isCloudflareIp(ip) {
     if (!ip)
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liberstudio/cloudflare-list",
-  "version": "2.3.4",
+  "version": "2.3.8",
   "description": "Modulo NestJS per gestione IP List Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
     "build": "npx tsc",
     "prepublishOnly": "npm run build",
     "version:bump": "npx tsx src/scripts/version-bump.ts",
-    "pub": "npm publish --access public"
+    "pub": "npm run build && npm publish --access public"
   },
   "publishConfig": {
     "access": "public"