@liberstudio/cloudflare-list 2.4.8 → 3.0.3

package/README.md

@@ -2,12 +2,12 @@
 
 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.
+Ogni richiesta che produce un `404` su un indirizzo senza nessuna rotta viene considerata sospetta (tipicamente bot, scanner, enumeratori: `/wp-admin`, `/.env`). Il `404` restituito da una rotta esistente (es. `GET /artworks/:id` di una risorsa che non c'è) non viene bloccato. 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
+Request → 404 rilevato dal middleware (solo se nessuna rotta ha risposto)
   └─ IP estratto (cf-connecting-ip / x-real-ip / x-forwarded-for)
        └─ throttle 5s per IP
             └─ log su file (se path non è silentPath)
@@ -47,6 +47,8 @@ Il modulo ignora automaticamente:
    - Action: `Block`
 6. Salvare la regola
 
+Con più account Cloudflare ripetere i passi per ogni account: ognuno ha la sua lista, il suo token e la sua regola WAF.
+
 ---
 
 ## Installazione
@@ -67,9 +69,10 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
 @Module({
   imports: [
     CloudflareAttacksModule.forRoot({
-      accountId: "abc123",
-      listId:    "def456",
-      apiToken:  "your-cloudflare-api-token",
+      accounts: [
+        { accountId: "abc123", listId: "def456", apiToken: "token-account-1" },
+        { accountId: "ghi789", listId: "jkl012", apiToken: "token-account-2" },
+      ],
       comment:   "Blocked by liberstudio/cloudflare-list",
       logPath:   "/var/log/nestjs-attacks.log",
       allowedIps:    ["1.2.3.4", "10.0.0.0/8"],
@@ -94,9 +97,18 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
       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"),
+        accounts: [
+          {
+            apiToken:  config.getOrThrow<string>("CLOUDFLARE_API_TOKEN"),
+            accountId: config.getOrThrow<string>("CLOUDFLARE_ACCOUNT_ID"),
+            listId:    config.getOrThrow<string>("CLOUDFLARE_LIST_ID"),
+          },
+          {
+            apiToken:  config.getOrThrow<string>("CLOUDFLARE_2_API_TOKEN"),
+            accountId: config.getOrThrow<string>("CLOUDFLARE_2_ACCOUNT_ID"),
+            listId:    config.getOrThrow<string>("CLOUDFLARE_2_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"],
@@ -120,9 +132,7 @@ export class AppModule {}
 
 | Opzione | Tipo | Obbligatorio | Descrizione |
 |---|---|---|---|
-| `apiToken` | `string` | si | Token API Cloudflare |
-| `accountId` | `string` | si | ID account Cloudflare |
-| `listId` | `string` | si | ID della IP List Cloudflare |
+| `accounts` | `CloudflareAccount[]` | si | Account Cloudflare su cui bannare (almeno uno), vedi sotto |
 | `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) |
@@ -133,6 +143,38 @@ export class AppModule {}
 | `telegramNotify` | `{ chatId: string }` | no | Invia una notifica Telegram quando un IP viene bannato |
 | `notifyProvider` | `"whatsapp" \| "telegram"` | no | Canale di notifica da usare (default: vedi sotto) |
 
+### `accounts` — ban su più account Cloudflare
+
+Ogni elemento di `accounts` è un `CloudflareAccount`:
+
+| Campo | Tipo | Obbligatorio | Descrizione |
+|---|---|---|---|
+| `apiToken` | `string` | si | Token API Cloudflare con accesso all'account |
+| `accountId` | `string` | si | ID account Cloudflare |
+| `listId` | `string` | si | ID della IP List dell'account |
+
+Ad ogni ban l'IP (o la subnet) viene aggiunto **in parallelo** alle liste di tutti gli account:
+
+- se un account fallisce, l'errore viene loggato con il suo `accountId` e gli altri proseguono;
+- se falliscono **tutti**, `updateIpList()` lancia `HttpException` con il primo errore;
+- `updateIpList()` e `blockIp()` ritornano un `CloudflareResponse[]` con le risposte degli account riusciti.
+
+Se lo stesso token ha accesso a più account, basta ripeterlo in ogni elemento.
+
+### Migrazione dalla 2.x
+
+La 3.0.0 è un breaking change: `apiToken`, `accountId` e `listId` non stanno più alla radice delle opzioni, ma dentro `accounts`.
+
+```typescript
+// 2.x
+{ apiToken: "...", accountId: "...", listId: "...", comment: "...", logPath: "..." }
+
+// 3.x
+{ accounts: [{ apiToken: "...", accountId: "...", listId: "..." }], comment: "...", logPath: "..." }
+```
+
+Inoltre `updateIpList()` ritorna `CloudflareResponse[]` invece di `CloudflareResponse`, e `blockIp()` ritorna `CloudflareResponse[] | null`.
+
 ### `notifyProvider` — scelta del canale di notifica
 
 Ad ogni ban viene inviata **una sola** notifica, sul canale scelto:
@@ -176,8 +218,11 @@ Il messaggio inviato sarà:
 Provenienza: Blocked by liberstudio/cloudflare-list
 IP: 1.2.3.4
 Subnet bloccata: 1.2.0.0/16
+Account: 2/2
 ```
 
+`Account` indica su quanti account configurati il ban è andato a buon fine. La notifica è sempre **una** per ban.
+
 Variabili d'ambiente richieste (lette automaticamente da `process.env`):
 ```env
 WA_URL=https://messaggistica.liberdesign.eu

package/dist/attacks.service.d.ts

@@ -7,11 +7,13 @@ export declare class AttacksService {
     private readonly API_URL;
     private readonly ASN_LOOKUP_URL;
     constructor(httpService: HttpService, options: CloudflareAttacksOptions);
-    blockIp(rawIp: string): Promise<CloudflareResponse | null>;
+    blockIp(rawIp: string): Promise<CloudflareResponse[] | null>;
     private sendNotification;
     private isWhatsappConfigured;
     private sendTelegramNotification;
     private sendWhatsappNotification;
     private lookupAsnRange;
-    updateIpList(cidr: string): Promise<CloudflareResponse>;
+    /** Aggiunge il CIDR alle liste di tutti gli account; ritorna le risposte degli account riusciti. */
+    updateIpList(cidr: string): Promise<CloudflareResponse[]>;
+    private addToAccountList;
 }

package/dist/attacks.service.js

@@ -47,7 +47,7 @@ let AttacksService = class AttacksService {
         if (asnRange && !(await (0, utils_1.googleBotOverlapsCidr)(asnRange))) {
             this.logger.error(`ASN range trovato per ${rawIp}: ${asnRange} — blocco intera subnet`);
             const result = await this.updateIpList(asnRange);
-            this.sendNotification(rawIp, asnRange);
+            this.sendNotification(rawIp, asnRange, result.length);
             return result;
         }
         if (asnRange) {
@@ -57,11 +57,11 @@ let AttacksService = class AttacksService {
         if (!cidr)
             throw new Error(`IP non valido: ${rawIp}`);
         const result = await this.updateIpList(cidr);
-        this.sendNotification(rawIp, cidr);
+        this.sendNotification(rawIp, cidr, result.length);
         return result;
     }
-    sendNotification(rawIp, cidr) {
-        const message = `🚨 IP bannato su Cloudflare\nProvenienza: ${this.options.comment}\nIP: ${rawIp}\nSubnet bloccata: ${cidr}`;
+    sendNotification(rawIp, cidr, okAccounts) {
+        const message = `🚨 IP bannato su Cloudflare\nProvenienza: ${this.options.comment}\nIP: ${rawIp}\nSubnet bloccata: ${cidr}\nAccount: ${okAccounts}/${this.options.accounts.length}`;
         const provider = this.options.notifyProvider ?? (this.isWhatsappConfigured() ? "whatsapp" : "telegram");
         if (provider === "whatsapp")
             this.sendWhatsappNotification(message);
@@ -114,11 +114,30 @@ let AttacksService = class AttacksService {
             return null;
         }
     }
+    /** Aggiunge il CIDR alle liste di tutti gli account; ritorna le risposte degli account riusciti. */
     async updateIpList(cidr) {
-        const { accountId, listId, apiToken, comment } = this.options;
+        const { accounts } = this.options;
+        this.logger.error(`Aggiungo ${cidr} alle liste Cloudflare (${accounts.length} account)`);
+        const results = await Promise.allSettled(accounts.map((account) => this.addToAccountList(account, cidr)));
+        const ok = [];
+        let firstError;
+        results.forEach((r, i) => {
+            if (r.status === "fulfilled") {
+                ok.push(r.value);
+                return;
+            }
+            firstError ??= r.reason;
+            const msg = r.reason instanceof Error ? r.reason.message : "Errore sconosciuto";
+            this.logger.error(`Aggiunta di ${cidr} fallita sull'account ${accounts[i].accountId}: ${msg}`);
+        });
+        if (ok.length === 0)
+            throw firstError;
+        return ok;
+    }
+    async addToAccountList(account, cidr) {
+        const { accountId, listId, apiToken } = account;
         const url = `${this.API_URL}/${accountId}/rules/lists/${listId}/items`;
-        this.logger.error(`Aggiungo ${cidr} alla lista Cloudflare`);
-        const body = [{ ip: cidr, comment }];
+        const body = [{ ip: cidr, comment: this.options.comment }];
         try {
             const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(url, body, {
                 headers: {

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

@@ -5,10 +5,13 @@ export interface TelegramNotifyOptions {
     chatId: string;
 }
 export type NotifyProvider = "whatsapp" | "telegram";
-export interface CloudflareAttacksOptions {
+export interface CloudflareAccount {
     apiToken: string;
     accountId: string;
     listId: string;
+}
+export interface CloudflareAttacksOptions {
+    accounts: CloudflareAccount[];
     comment: string;
     logPath: string;
     allowedIps?: string[];

package/dist/middleware/attack-logger.middleware.d.ts

@@ -15,6 +15,7 @@ export declare class AttackLoggerMiddleware implements NestMiddleware, OnModuleD
     private isThrottled;
     private sanitize;
     private ensureDirectoryExists;
+    private hasRealRoute;
     private isExcluded;
     private isSilent;
     onModuleDestroy(): void;

package/dist/middleware/attack-logger.middleware.js

@@ -42,7 +42,7 @@ let AttackLoggerMiddleware = AttackLoggerMiddleware_1 = class AttackLoggerMiddle
     }
     use(req, res, next) {
         res.on("finish", () => {
-            if (res.statusCode === 404 && !this.isExcluded(req.url)) {
+            if (res.statusCode === 404 && !this.hasRealRoute(req) && !this.isExcluded(req.url)) {
                 this.handleSuspicious(req);
             }
         });
@@ -85,7 +85,7 @@ let AttackLoggerMiddleware = AttackLoggerMiddleware_1 = class AttackLoggerMiddle
             this.logger.warn(`IP non valido: ${ip}`);
             return;
         }
-        this.logger.warn(`Provenienza ${ip}: socket=${origin.remoteAddress} host=${origin.host} cf-ray=${origin.cfRay}`);
+        this.logger.warn(`Provenienza ${ip}: ${req.method} ${this.sanitize(req.originalUrl)} → 404, socket=${origin.remoteAddress} host=${origin.host} cf-ray=${origin.cfRay}`);
         this.attSrv.blockIp(ip).catch((err) => {
             const msg = err instanceof Error ? err.message : "Errore sconosciuto";
             this.logger.error(`Aggiornamento Cloudflare fallito: ${msg}`);
@@ -110,6 +110,13 @@ let AttackLoggerMiddleware = AttackLoggerMiddleware_1 = class AttackLoggerMiddle
             this.logger.log(`Cartella dei log creata: ${dir}`);
         }
     }
+    // Un 404 di una rotta esistente (es. risorsa non trovata) non è una scansione.
+    // Express lascia req.route solo se una rotta ha risposto; Nest 12 con prefisso globale
+    // gestisce gli indirizzi senza rotta con il catch-all '*path', che quindi non conta.
+    hasRealRoute(req) {
+        const path = req.route?.path;
+        return path !== undefined && path !== "*path";
+    }
     isExcluded(url) {
         const excluded = this.options.excludedPaths ?? [];
         return excluded.some((p) => (p instanceof RegExp ? p.test(url) : url.startsWith(p)));

package/dist/scripts/version-bump.js

@@ -20,4 +20,10 @@ if (minor >= 10) {
 pkg.version = `${major}.${minor}.${patch}`;
 // Scrittura package.json
 (0, node_fs_1.writeFileSync)(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+// Allineamento package-lock.json (versione radice e del pacchetto "")
+const lockPath = (0, node_path_1.resolve)(__dirname, '../../package-lock.json');
+const lock = JSON.parse((0, node_fs_1.readFileSync)(lockPath, 'utf8'));
+lock.version = pkg.version;
+lock.packages[''].version = pkg.version;
+(0, node_fs_1.writeFileSync)(lockPath, JSON.stringify(lock, null, 2) + '\n');
 console.log(`Version updated to ${pkg.version}`);

package/dist/utils/options.validator.js

@@ -1,16 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOptions = validateOptions;
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
 function validateOptions(opzioni) {
     if (!opzioni)
         throw new Error("CloudflareAttacksOptions è obbligatorio");
-    const campiObbligatori = ["apiToken", "accountId", "listId", "comment", "logPath"];
+    const campiObbligatori = ["comment", "logPath"];
     for (const campo of campiObbligatori) {
-        const valore = opzioni[campo];
-        if (typeof valore !== "string" || valore.trim().length === 0) {
+        if (!isNonEmptyString(opzioni[campo])) {
             throw new Error(`CloudflareAttacksOptions.${campo} deve essere una stringa non vuota`);
         }
     }
+    if (!Array.isArray(opzioni.accounts) || opzioni.accounts.length === 0) {
+        throw new Error("CloudflareAttacksOptions.accounts deve essere un array non vuoto");
+    }
+    const campiAccount = ["apiToken", "accountId", "listId"];
+    opzioni.accounts.forEach((account, i) => {
+        for (const campo of campiAccount) {
+            if (!isNonEmptyString(account?.[campo])) {
+                throw new Error(`CloudflareAttacksOptions.accounts[${i}].${campo} deve essere una stringa non vuota`);
+            }
+        }
+    });
     const provider = opzioni.notifyProvider;
     if (provider !== undefined && provider !== "whatsapp" && provider !== "telegram") {
         throw new Error(`CloudflareAttacksOptions.notifyProvider deve essere "whatsapp" o "telegram"`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liberstudio/cloudflare-list",
-  "version": "2.4.8",
+  "version": "3.0.3",
   "description": "Modulo NestJS per gestione IP List Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,6 +14,7 @@
   ],
   "scripts": {
     "build": "npx tsc",
+    "test": "vitest run",
     "prepublishOnly": "npm run build",
     "version:bump": "npx tsx src/scripts/version-bump.ts",
     "pub": "npm run build && npm publish --access public"
@@ -35,12 +36,14 @@
     "@nestjs/axios": "^12.0.1",
     "@nestjs/common": "^12.4.0",
     "@nestjs/core": "^12.4.0",
+    "@nestjs/platform-express": "^12.4.2",
     "@types/express": "^5.0.6",
-    "@types/node": "^20.19.43",
+    "@types/node": "^24.19.2",
     "axios": "^1.21.0",
     "rxjs": "^7.8.2",
     "simple-git-hooks": "^2.13.1",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^5.1.0"
   },
   "allowScripts": {
     "simple-git-hooks@2.13.1": true