Security Lab

SQL Injection - Auth Bypass SQLi Facile Injection SQL, Contournement auth, UNION-based

XSS - Stored XSS Moyen DOM manipulation, Cookie stealing, CSP bypass

SSRF - Cloud Metadata SSRF Difficile Server-Side Request Forgery, Cloud pivoting, DNS rebinding

IDOR - User Profile IDOR Facile Broken Access Control, API enum, Horizontal privesc

JWT - Weak Secret & Algorithm Confusion JWT Moyen Token forgery, HMAC cracking, alg:none bypass

CSP Bypass - Inline Script CSP Difficile Content-Security-Policy, Nonce leak, Script gadgets

File Upload - Webshell Upload Difficile Double extension, Null byte, Content-Type spoof

Bash - VM Privilege Escalation System Moyen SUID exploitation, sudo misconfiguration, PATH hijacking

Bytecode Analysis - Custom VM Reverse Difficile Analyse bytecode, Réimplémentation Python, Instruction set

JS Deobfuscation - Packer Reverse Moyen Déobfuscation, AST analysis, Eval unpacking

ELF - Debugger Custom Reverse Difficile ptrace, Breakpoints, Register manipulation, ELF parsing

              
              
              
              bytecode_vm.py — Custom VM Interpreter
            
# Réimplémentation Python du bytecode custom
def execute(bytecode, memory):
    pointer = 0
    stack = []
    while pointer < len(bytecode):
        opcode = bytecode[pointer]
        if opcode == 0x01:   # PUSH
            stack.append(bytecode[pointer + 1])
            pointer += 2
        elif opcode == 0x02: # ADD
            a, b = stack.pop(), stack.pop()
            stack.append(a + b)
            pointer += 1
        elif opcode == 0x03: # STORE
            addr = bytecode[pointer + 1]
            memory[addr] = stack.pop()
            pointer += 2
        elif opcode == 0xFF: # HALT
            break
    return memory

Problème

Formulaire de login sans validation côté serveur. L'input utilisateur est concaténé directement dans la requête SQL.

Analyse

Interception avec Burp Suite. Le paramètre password est injecté dans une requête WHERE sans échappement. Pas de WAF détecté. Pas de prepared statements.

Méthode

Payload : ' OR 1=1 -- dans le champ password. La condition OR 1=1 rend la clause WHERE toujours vraie, le -- commente le reste de la requête.

Résultat

Accès admin obtenu. Extraction de la table users complète via UNION-based injection en 3 requêtes.

Leçon retenue

Toujours utiliser des prepared statements. Jamais de concaténation de strings dans les requêtes SQL. Implémenter un WAF en couche supplémentaire.

Problème

Binaire inconnu qui exécute un bytecode custom. Pas de symboles, pas de documentation. Le flag est caché dans la mémoire après exécution.

Analyse

Reverse engineering avec Ghidra. Identification de 8 opcodes (PUSH, ADD, SUB, XOR, STORE, LOAD, JMP, HALT). Chaque instruction fait 1-3 bytes.

Méthode

Réimplémentation complète de la VM en Python. Exécution pas-à-pas du bytecode avec dump mémoire après chaque instruction pour tracer le déchiffrement du flag.

Résultat

Flag extrait après déchiffrement XOR en 3 passes. La clé était dérivée des 4 premiers bytes du bytecode lui-même.

Leçon retenue

La réimplémentation d'un interpréteur donne un contrôle total sur l'exécution. Toujours instrumenter avant de bruteforce.

Problème

Application avec authentification JWT. Le token est signé en HS256 mais le serveur accepte aussi alg: none.

Analyse

Décodage du token avec jwt.io. Header modifiable. Le secret est faible (4 caractères). Le serveur ne valide pas l'algorithme de manière stricte.

Méthode

Double approche : 1) Cracking du secret HMAC avec hashcat + rockyou.txt en 12 secondes. 2) Forge d'un token avec alg: none et payload admin.

Résultat

Escalade de privilèges : user → admin. Accès complet au panel d'administration.

Leçon retenue

Forcer l'algorithme côté serveur (whitelist). Secret ≥ 256 bits. Implémenter une expiration courte + refresh token rotation.

A01 — Broken Access Control

IDOR, escalade de privilèges, manipulation de rôles, bypass d'autorisation via tampering de requêtes.

Vérifié

A02 — Cryptographic Failures

Stockage de mots de passe (bcrypt vs MD5), certificats TLS, algorithmes obsolètes, key management.

Vérifié

A03 — Injection

SQL, NoSQL, OS command, LDAP injection. Validation côté serveur, parameterized queries, input sanitization.

Vérifié

A07 — Auth Failures

Brute force, session fixation, credential stuffing, JWT weaknesses, absence de MFA.

Vérifié

A09 — Security Logging

Couverture des événements critiques, détection d'intrusion, alerting temps réel, log tamper protection.

En cours

A05 — Security Misconfiguration

Headers HTTP, CORS policy, ports ouverts, services par défaut, server hardening, debug mode en prod.

En cours

SQL Injection — Requêtes paramétrées

                
                
                
                vulnerable.py
                VULNÉRABLE
              
# Requête SQL par concaténation
def login(username, password):
    query = "SELECT * FROM users"
    query += " WHERE user='" + username
    query += "' AND pass='" + password + "'"
    cursor.execute(query)
    return cursor.fetchone()

                
                
                
                secure.py
                CORRIGÉ
              
# Prepared statement
def login(username, password):
    query = "SELECT * FROM users"
    query += " WHERE user = %s AND pass = %s"
    cursor.execute(query, (username, password))
    return cursor.fetchone()

XSS Stored — Échappement HTML

                
                
                
                vulnerable.js
                VULNÉRABLE
              
// Input injecté dans le DOM
function addComment(text) {
    const div = document.createElement('div');
    div.innerHTML = text; // XSS!
    comments.appendChild(div);
}

                
                
                
                secure.js
                CORRIGÉ
              
// textContent pour l'échappement
function addComment(text) {
    const div = document.createElement('div');
    div.textContent = text; // Safe
    comments.appendChild(div);
}

Broken Auth — JWT avec expiration & refresh

                
                
                
                vulnerable-auth.js
                VULNÉRABLE
              
// JWT sans expiration ni rotation
const token = jwt.sign(
    { userId: user.id, role: user.role },
    'secret123'
    // Pas d'expiration !
);

                
                
                
                secure-auth.js
                CORRIGÉ
              
// JWT + expiration + refresh
const accessToken = jwt.sign(
    { userId: user.id, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: '15m' }
);
const refreshToken = jwt.sign(
    { userId: user.id },
    process.env.REFRESH_SECRET,
    { expiresIn: '7d' }
);

La cybersécurité appliquée aux smart contracts combine analyse de code, architecture système et compréhension des mécanismes DeFi. Voici les vulnérabilités que j'étudie et audite.

Reentrancy

Appels récursifs externes avant mise à jour d'état. Pattern checks-effects-interactions et ReentrancyGuard d'OpenZeppelin.

Critical

Integer Overflow

Dépassement arithmétique avant Solidity 0.8. SafeMath, checked arithmetic, et audit des calculs de tokens.

High

Access Control Flaws

Fonctions admin non protégées, modifier manquants, initializers non sécurisés sur les proxies.

Critical

Oracle Manipulation

Manipulation de prix via flash loans. Oracles décentralisés (Chainlink), TWAP, et validation multi-sources.

High

Upgradeable Proxy Risks

Storage collisions, uninitialized implementations, function selector clashes entre proxy et implementation.

Medium

Front-Running & MEV

Transaction ordering exploitation, sandwich attacks, commit-reveal schemes et private mempools.

Medium

Reentrancy — checks-effects-interactions

                
                
                
                Vulnerable.sol
                VULNÉRABLE
              
// Appel externe avant mise à jour
function withdraw() public {
    uint bal = balances[msg.sender];
    (bool ok, ) = msg.sender.call
        {value: bal}("");
    require(ok);
    balances[msg.sender] = 0; // Trop tard!
}

                
                
                
                Secure.sol
                CORRIGÉ
              
// Checks-Effects-Interactions
function withdraw() public
    nonReentrant {
    uint bal = balances[msg.sender];
    require(bal > 0);
    balances[msg.sender] = 0; // Avant!
    (bool ok, ) = msg.sender.call
        {value: bal}("");
    require(ok);
}

Scope

scope.txt

$ cat scope.txt
Cible : Application web e-commerce
Périmètre : Front-end, API REST, Base de données
Méthode : Black-box → Grey-box
Durée : 5 jours ouvrés
Outils : Burp Suite Pro, Nmap, SQLMap, Nikto

Findings

Critical

SQL Injection sur /api/products

Le paramètre id est injectable. Extraction complète de la base via UNION-based injection.

High

Stored XSS dans les avis produits

Le champ commentaire accepte du HTML non filtré. Possible vol de session admin.

Medium

CORS trop permissif

Access-Control-Allow-Origin défini sur *. Requêtes cross-origin malveillantes possibles.

Low

Headers de sécurité manquants

Absence de X-Content-Type-Options, X-Frame-Options et Content-Security-Policy.

Recommandations

P1 Implémenter des requêtes paramétrées sur tous les endpoints API

P1 Sanitiser tous les inputs utilisateur avec DOMPurify côté front

P2 Restreindre CORS aux domaines autorisés uniquement

P3 Ajouter les headers de sécurité via reverse proxy

Testez une attaque XSS dans un environnement sécurisé. Entrez du HTML/JS et observez le rendu.

Payload XSS :

Rendu (iframe sandboxé) :

Fix : Utiliser textContent au lieu de innerHTML, ou sanitiser avec DOMPurify.sanitize(input). Le navigateur n'interprétera plus le HTML/JS injecté.

Simulez une injection SQL sur un formulaire de login. Observez comment la requête est construite.

Username :

Password :

Prepared Statements

Requête SQL générée :

SELECT * FROM users WHERE username = '' AND password = ''

Fix : Utiliser des prepared statements avec des placeholders ? ou %s. Le moteur SQL traite les paramètres comme des données, jamais comme du code.

Challenges & Write-ups

Web

Reverse / Bash VM

Analyse technique détaillée

SQL Injection — Auth Bypass

Bytecode Analysis — Custom VM

JWT — Algorithm Confusion & Weak Secret

OWASP Top 10 — Mini Audit

Vulnérabilité & Correction

SQL Injection — Requêtes paramétrées

XSS Stored — Échappement HTML

Broken Auth — JWT avec expiration & refresh

Sécurité des Smart Contracts

Reentrancy

Integer Overflow

Access Control Flaws

Oracle Manipulation

Upgradeable Proxy Risks

Front-Running & MEV

Reentrancy — checks-effects-interactions

Rapport de Pentest (anonymisé)

Rapport d'Audit de Sécurité

Scope

Findings

Recommandations

Sandbox Éducatif

XSS Sandbox

SQLi Sandbox