Add web security guard

.claude-plugin/marketplace.json

@@ -1670,6 +1670,25 @@
         "security",
         "compliance"
       ]
+    },
+    {
+      "name": "web-security-guard",
+      "source": "./plugins/web-security-guard",
+      "description": "Integrated security for websites and apps: hardening, secure authentication (email verification, 2FA, passkeys), payment privacy, WAF defense agent with lockdown, 4-layer Fortress architecture and automated GitHub security workflows.",
+      "version": "0.2.1",
+      "author": {
+        "name": "Fede",
+        "url": "https://github.com/ayalaphiscan"
+      },
+      "category": "Security, Compliance, & Legal",
+      "homepage": "https://github.com/ayalaphiscan/web-security-guard",
+      "keywords": [
+        "security",
+        "waf",
+        "hardening",
+        "2fa",
+        "payments"
+      ]
     }
   ]
-}
+}

README-zh.md

@@ -188,6 +188,7 @@
 - [enterprise-security-reviewer](./plugins/enterprise-security-reviewer)
 - [legal-advisor](./plugins/legal-advisor)
 - [legal-compliance-checker](./plugins/legal-compliance-checker)
+- [web-security-guard](./plugins/web-security-guard)
 
 
 ## 使用教程

README.md

@@ -188,6 +188,7 @@ Install or disable them dynamically with the `/plugin` command — enabling you
 - [enterprise-security-reviewer](./plugins/enterprise-security-reviewer)
 - [legal-advisor](./plugins/legal-advisor)
 - [legal-compliance-checker](./plugins/legal-compliance-checker)
+- [web-security-guard](./plugins/web-security-guard)
 
 
 ## Tutorials

plugins/web-security-guard/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "web-security-guard",
+  "version": "0.2.1",
+  "description": "Sicurezza integrata per siti e app: hardening, autenticazione sicura (verifica email, 2FA, passkey), privacy su pagamenti e abbonamenti, agente di difesa con lockdown, architettura Fortezza a 4 livelli (scudo invisibile, server nascosto, cassaforte offline) e workflow GitHub di scansione automatica.",
+  "author": { "name": "Fede" },
+  "keywords": ["security", "payments", "privacy", "2fa", "github-actions", "waf"]
+}

plugins/web-security-guard/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fede
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

plugins/web-security-guard/README.md

@@ -0,0 +1,57 @@
+# Web Security Guard
+
+[![Claude Code Plugin](https://img.shields.io/badge/Claude%20Code-plugin-d97757)](https://docs.claude.com/en/docs/claude-code)
+[![Version](https://img.shields.io/badge/version-0.2.1-blue)](https://github.com/ayalaphiscan/web-security-guard/releases)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Built with Claude Fable 5](https://img.shields.io/badge/built%20with-Claude%20Fable%205-d97757)](https://claude.com/claude-code)
+
+A security plugin for [Claude Code](https://docs.claude.com/en/docs/claude-code) and Claude Cowork that turns Claude into a security-aware engineer. It bundles 6 skills, 2 slash commands and ready-to-deploy infrastructure templates covering the full lifecycle: hardening, authentication, payments privacy, active defense, stealth architecture and CI security.
+
+```
+/plugin marketplace add ayalaphiscan/web-security-guard
+```
+
+## What's inside
+
+| Skill | What it does |
+|---|---|
+| `hardening-siti` | Applies security hardening whenever a site/app is built or reviewed: security headers, CSP, HTTPS, input validation, cookies, CORS, uploads, OWASP Top 10 |
+| `autenticazione-sicura` | Secure auth flows: email verification codes, 2FA/TOTP, passkeys, password hashing, sessions, account recovery |
+| `difesa-attacchi` | Installs a defense agent (WAF middleware for Express) that detects SQLi, XSS, path traversal, brute force and bots — with rate limiting, IP blocklist and a data-preserving lockdown mode |
+| `privacy-pagamenti` | Protects payment data: secure Stripe/PayPal integration, webhook signature verification, PCI-DSS, GDPR, data minimization |
+| `architettura-fortezza` | Designs a 4-layer "Fortress": invisible reverse-proxy shield, hidden origin server, WireGuard mesh, air-gapped offline vault with encrypted backups. Includes all deployment templates in `references/fortezza/` |
+| `sicurezza-github` | Adds automated security workflows to your repos: dependency scanning, secret scanning, CodeQL, Dependabot |
+
+**Commands:** `/proteggi-sito` (install all protections in the current project) · `/security-audit` (full security audit with report)
+
+**Battle-tested defense agent.** The included `guardian` middleware (plain Node.js, zero runtime dependencies) handles malformed-URI evasion attempts, prunes its memory maps to avoid unbounded growth, and ships in two flavors: standard (with explanatory 403s) and stealth (attackers get their connection dropped, no response at all).
+
+## Installation
+
+### Claude Code
+```
+/plugin marketplace add ayalaphiscan/web-security-guard
+/plugin install web-security-guard@web-security-guard
+```
+
+### Claude Cowork (desktop app)
+Download this repository as a zip, rename it to `web-security-guard.plugin`, then install it from **Settings → Capabilities**.
+
+## Usage examples
+
+- *"Build me a login page"* → hardening + secure authentication kick in automatically
+- *"Add Stripe subscriptions"* → payment privacy rules are applied
+- *"I want my server hidden and my data in a box"* → Fortress architecture, with templates
+- `/security-audit` → full report of issues and fixes for the current project
+
+## Honest limits (by design, stated in the skills)
+
+The public web port can never be invisible — what can be made invisible are SSH, admin, the real origin server and the vault. Large volumetric DDoS still requires an external CDN/WAF. The skills promise *minimal attack surface, unreachable core, recoverable data* — never "unhackable".
+
+## License
+
+[MIT](LICENSE) — © ayalaphiscan (Fede)
+
+---
+
+🤖 Built with **Claude Fable 5** via [Claude Code](https://claude.com/claude-code) — skills, templates and this very README were developed together with the model the plugin runs on.

plugins/web-security-guard/commands/proteggi-sito.md

@@ -0,0 +1,16 @@
+---
+description: Installa nel progetto corrente tutte le protezioni - middleware anti-attacco, security headers, file di sicurezza GitHub e hardening
+---
+
+Installa le protezioni di sicurezza nel progetto della cartella di lavoro corrente (se non c'è una cartella connessa, chiedila con request_cowork_directory). Prima rileva lo stack (Node/Express, Python, PHP, sito statico) guardando i file del progetto.
+
+Applica nell'ordine:
+
+1. **Agente anti-attacco** (skill difesa-attacchi): copia e adatta `guardian-express.js` in `security/guardian.js` e integralo nell'entry point dell'app. Per stack non-Node, riscrivi la stessa logica nel linguaggio del progetto. Configura `skipPaths` per eventuali webhook di pagamento.
+2. **Security headers e hardening** (skill hardening-siti): aggiungi helmet/headers, correggi cookie, CORS e gestione errori dove necessario.
+3. **File GitHub** (skill sicurezza-github): crea `.github/workflows/security.yml` e `.github/dependabot.yml` adattati al linguaggio del progetto; verifica `.gitignore`.
+4. **Verifiche pagamenti e autenticazione**: se il progetto gestisce pagamenti o login, controlla i punti critici delle skill privacy-pagamenti e autenticazione-sicura e correggi ciò che è automatizzabile; segnala il resto.
+
+Non rimuovere funzionalità esistenti; se una modifica rischia di rompere qualcosa, chiedi prima conferma all'utente con AskUserQuestion.
+
+Alla fine presenta un riepilogo: cosa è stato installato, cosa deve fare l'utente sul suo hosting/GitHub (attivare secret scanning, push protection, WAF/CDN), e come si attiva/disattiva manualmente il lockdown (file flag LOCKDOWN).

plugins/web-security-guard/commands/security-audit.md

@@ -0,0 +1,20 @@
+---
+description: Esegue un audit di sicurezza completo del progetto corrente e produce un report con problemi e correzioni
+---
+
+Esegui un audit di sicurezza del progetto nella cartella di lavoro corrente (se non c'è una cartella connessa, chiedila con request_cowork_directory).
+
+Analizza il codice cercando, in ordine di gravità:
+
+1. **Segreti nel codice**: API key, password, token, chiavi private hardcoded o in file committati (controlla anche che `.env` sia in `.gitignore`).
+2. **Injection**: query SQL costruite con concatenazione, input utente in comandi shell, `eval`, percorsi file da input.
+3. **XSS**: input utente inserito in HTML senza escaping (`innerHTML`, template senza autoescape).
+4. **Autenticazione**: password non hashate o con hash deboli (MD5/SHA1), assenza di rate limiting sul login, sessioni/cookie senza flag di sicurezza, mancanza di verifica email o 2FA dove appropriato (confronta con la skill autenticazione-sicura).
+5. **Pagamenti**: dati carta salvati o loggati, webhook senza verifica firma, prezzi presi dal client (confronta con la skill privacy-pagamenti).
+6. **Configurazione**: security headers mancanti, CORS aperto, errori che espongono stack trace, HTTP senza redirect a HTTPS (confronta con la skill hardening-siti).
+7. **Dipendenze**: esegui `npm audit` o `pip-audit` se disponibili nel sandbox.
+8. **Repo GitHub**: presenza di workflow di sicurezza e dependabot (skill sicurezza-github).
+
+Produci un report con: riepilogo (numero problemi per gravità Critica/Alta/Media/Bassa), per ogni problema il file e la riga, perché è pericoloso (in linguaggio semplice), e la correzione concreta. Salva il report come `security-audit.md` negli outputs e presentalo con present_files.
+
+Alla fine chiedi all'utente se vuole che applichi subito le correzioni (in tal caso applica le skill di questo plugin).

plugins/web-security-guard/skills/architettura-fortezza/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: architettura-fortezza
+description: Progetta e installa un'infrastruttura di sicurezza a 4 livelli dove il cuore (dati e chiavi) è offline e staccato, lo scudo è invisibile agli scanner e il server reale è nascosto. Usare quando l'utente vuole un sistema "chiuso in una scatola", un reverse proxy invisibile, un'alternativa self-hosted a Cloudflare, server nascosto, VPN WireGuard, o backup offline irraggiungibili. Trigger - "fortezza", "scatola chiusa", "offline", "invisibile", "nascosto", "mini cloudflare", "reverse proxy", "air gap", "cassaforte", "WireGuard".
+---
+
+# Architettura Fortezza (4 livelli)
+
+Quando l'utente vuole un sistema "blindato" dove il cuore è staccato e lo scudo è
+invisibile, proporre e installare questa architettura. I file template completi
+(proxy guardian, Caddy, docker-compose, firewall, WireGuard, backup cifrati) sono
+in `references/fortezza/` dentro questa skill; questa skill spiega come adattarli.
+
+## Premessa onesta da dare SEMPRE all'utente
+La porta web pubblica non può essere invisibile: se i visitatori la raggiungono,
+la raggiunge anche chi attacca. Invisibili possono diventare invece SSH,
+l'amministrazione, il server reale e la cassaforte. E i DDoS volumetrici enormi
+restano gestibili solo con un CDN/WAF esterno (es. Cloudflare free) davanti allo
+scudo. Non promettere "non attaccabile": promettere "superficie ridotta al minimo,
+cuore irraggiungibile, dati sempre recuperabili".
+
+## I quattro livelli
+
+1. **Scudo invisibile** — unica macchina pubblica. Caddy (HTTPS + rimozione
+   impronte) → proxy `guardian` (WAF, rate limit, blocklist silenziosa, lockdown,
+   honeypot). Firewall stealth: solo 80/443 visibili, resto in DROP, niente ping.
+2. **Server origine nascosto** — sito + DB, nessuna porta pubblica, accetta solo
+   lo scudo via VPN. L'app ascolta sull'IP VPN, mai esposta dal provider.
+3. **WireGuard** — rete privata cifrata tra scudo, origine e admin. Non risponde
+   senza chiave valida → invisibile agli scanner. Solo gli `AllowedIPs` passano.
+4. **Cassaforte offline** — air-gapped, custodisce la chiave privata. Backup
+   cifrati con chiave pubblica (il server cifra ma non può decifrare). La
+   cassaforte va a prendere i backup (sola andata); il server non la conosce.
+
+## Principi di progettazione da rispettare
+- **Minima superficie**: ogni livello espone solo ciò che serve al livello accanto.
+- **Conoscenza parziale**: ogni macchina conosce solo il vicino, mai l'intera catena.
+- **One-way verso il cuore**: nessun percorso che parta dal server e arrivi alla cassaforte.
+- **Cifratura asimmetrica**: chi può essere compromesso (il server) ha solo la chiave pubblica.
+- **Silenzio**: agli attaccanti non si risponde (stealth), per non dare impronte né feedback.
+- **Difesa in profondità**: questa architettura si SOMMA alle altre skill del plugin
+  (hardening-siti, difesa-attacchi, privacy-pagamenti, autenticazione-sicura), non le sostituisce.
+
+## Installazione (ordine)
+1. Cassaforte: generare le chiavi offline (`genera-chiavi.sh`).
+2. WireGuard su scudo, origine, admin.
+3. Origine: avviare app su IP VPN, poi `firewall-origine.sh`.
+4. Scudo: configurare `ORIGIN_URL` e dominio, `docker compose up -d --build`, `firewall-stealth.sh`.
+5. Backup: cron notturno di `backup-cifrato.sh` sull'origine; pull periodico dalla cassaforte.
+
+## Verifica
+Da macchina esterna `nmap -Pn IP_SCUDO`: solo 80/443. SSH/WireGuard invisibili.
+Il server origine non deve rispondere. Provare un ripristino di backup sulla
+cassaforte per confermare che la catena funziona.

plugins/web-security-guard/skills/architettura-fortezza/references/fortezza/README.md

@@ -0,0 +1,68 @@
+# Fortezza — architettura a 4 livelli
+
+Sistema di sicurezza "a scatole chiuse": il cuore (dati e chiavi) è staccato e
+offline, lo scudo è invisibile agli scanner, e ogni livello conosce solo quello
+immediatamente accanto. Un attaccante che superasse un livello non troverebbe il
+successivo, perché non ne conosce nemmeno l'indirizzo.
+
+## I quattro livelli
+
+1. **Scudo invisibile** (`scudo/`) — l'unica macchina esposta a internet. Caddy
+   gestisce HTTPS e nasconde ogni impronta del server; il proxy `guardian`
+   filtra le richieste malevole, applica rate limiting, blocca gli IP ostili in
+   silenzio (modalità stealth: niente risposte agli attaccanti) e attiva il
+   lockdown sotto attacco. Il firewall (`firewall-stealth.sh`) lascia visibili
+   solo le porte 80/443 e fa sparire tutto il resto.
+
+2. **Server origine nascosto** (`origine/`) — il sito e il database reali. Non
+   ha alcuna porta pubblica: accetta connessioni **solo dallo scudo**, e solo
+   attraverso la VPN. Per il mondo esterno questa macchina non esiste.
+
+3. **Corridoio invisibile WireGuard** (`vpn-wireguard/`) — la rete privata
+   cifrata che collega scudo, origine e amministratore. WireGuard non risponde a
+   chi non ha la chiave: agli scanner appare come nulla.
+
+4. **Cassaforte offline** (`cassaforte/`) — il cuore. Macchina air-gapped che
+   custodisce la chiave privata e i backup. È la cassaforte ad andare a prendere
+   i backup (sola andata): il server non può raggiungerla né sa che esiste. I
+   backup sono cifrati con la chiave pubblica, quindi il server può crearli ma
+   non leggerli — solo la cassaforte può.
+
+```
+Internet ─▶ [Scudo: Caddy + guardian]  ──VPN──▶  [Origine: sito + DB]
+                  (l'unico visibile)                      │ crea backup cifrati
+                                                          ▼
+                                          [Cassaforte OFFLINE]  ◀── va a prenderli (sola andata)
+                                          chiave privata + ripristino
+```
+
+## Ordine di installazione
+
+1. **Cassaforte** (offline): `bash cassaforte/genera-chiavi.sh` → ottieni chiave
+   privata (resta qui) e pubblica (copiala sul server origine).
+2. **WireGuard** su tutte e tre le macchine: segui `vpn-wireguard/README-wireguard.md`.
+3. **Server origine**: avvia l'app sull'IP VPN, poi `sudo bash origine/firewall-origine.sh`.
+4. **Scudo**: imposta `ORIGIN_URL` (IP VPN dell'origine) nel `docker-compose.yml`,
+   il dominio nel `Caddyfile`, poi `docker compose up -d --build` e
+   `sudo bash scudo/firewall-stealth.sh`.
+5. **Backup**: pianifica `origine/../cassaforte/backup-cifrato.sh` (cron notturno
+   sul server origine). Periodicamente accendi la cassaforte e lancia
+   `cassaforte/pull-su-cassaforte.sh`.
+
+## Verifica dell'invisibilità
+Da una macchina esterna: `nmap -Pn TUO_IP_SCUDO` deve mostrare solo 80/443.
+SSH e WireGuard non devono comparire. Il server origine non deve rispondere affatto.
+
+## Cosa questa architettura fa e non fa
+- **Fa**: rende il cuore (dati/chiavi) irraggiungibile, nasconde la struttura
+  interna, blocca attacchi applicativi, garantisce backup illeggibili e
+  ripristinabili anche dopo una compromissione totale del server.
+- **Non fa**: rendere invisibile la porta web pubblica (se la trovano i clienti,
+  la trova chi attacca) né assorbire DDoS volumetrici enormi. Per quelli, metti
+  il piano gratuito di Cloudflare davanti allo scudo: i due si combinano bene.
+
+## Sicurezza operativa
+Le chiavi private non lasciano mai la loro macchina. Ruota le chiavi se sospetti
+una compromissione. Tieni una copia della chiave privata della cassaforte su
+supporto fisico in un cassetto: se la perdi, i backup diventano illeggibili anche
+per te.

plugins/web-security-guard/skills/architettura-fortezza/references/fortezza/cassaforte/backup-cifrato.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# backup-cifrato.sh — gira sul SERVER ORIGINE.
+# Crea un backup del database cifrato con la CHIAVE PUBBLICA della cassaforte.
+#
+# Punto chiave dell'architettura "scatola chiusa":
+# il server origine ha SOLO la chiave PUBBLICA. Può cifrare e creare backup,
+# ma NON può rileggerli. Solo la cassaforte offline, che custodisce la chiave
+# PRIVATA, può decifrarli. Anche se un attaccante prendesse il controllo totale
+# del server, otterrebbe archivi illeggibili.
+set -euo pipefail
+
+OUT_DIR="${OUT_DIR:-/var/backups/fortezza}"
+PUB_KEY="${PUB_KEY:-/etc/fortezza/cassaforte.pub}"   # solo chiave pubblica, mai la privata
+STAMP="$(date +%Y%m%d-%H%M%S)"
+TMP="$(mktemp -d)"
+mkdir -p "$OUT_DIR"
+
+echo "[*] Dump del database..."
+# Adatta al tuo DB. Esempi:
+#   PostgreSQL: pg_dump "$DATABASE_URL" > "$TMP/db.sql"
+#   MySQL:      mysqldump --single-transaction db > "$TMP/db.sql"
+pg_dump "${DATABASE_URL:?DATABASE_URL mancante}" > "$TMP/db.sql"
+
+echo "[*] Comprimo e cifro con la chiave pubblica della cassaforte (age)..."
+# 'age' = strumento di cifratura moderno e semplice (https://age-encryption.org)
+tar -czf "$TMP/backup.tar.gz" -C "$TMP" db.sql
+age -R "$PUB_KEY" -o "$OUT_DIR/backup-$STAMP.tar.gz.age" "$TMP/backup.tar.gz"
+
+# Pulizia dei file in chiaro
+shred -u "$TMP/db.sql" "$TMP/backup.tar.gz" 2>/dev/null || rm -f "$TMP/db.sql" "$TMP/backup.tar.gz"
+rmdir "$TMP" 2>/dev/null || true
+
+# Conserva solo gli ultimi 14 backup cifrati
+ls -1t "$OUT_DIR"/backup-*.tar.gz.age 2>/dev/null | tail -n +15 | xargs -r rm -f
+
+echo "[✓] Backup cifrato pronto: $OUT_DIR/backup-$STAMP.tar.gz.age"
+echo "    Questo file è ILLEGGIBILE senza la chiave privata custodita offline."