> ## Content Index
> Fetch the complete content index at: https://yokai.hakaisecurity.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# LDAP - Entender Para Atacar
- URL: https://yokai.hakaisecurity.io/ldap-entender-para-atacar/
- Published: 2025-10-10T14:26:20.000Z
- Updated: 2026-09-11T22:09:45.000Z
- Author: alkarramax junior
- Tags: #wp, pt-br, #pair-ldap, Insights Blog

Quando realizamos testes internos, é comum o uso do LDAP (Lightweight Directory Access Protocol), mas pouco se entende sobre sua real função, utilidade e o quão poderoso esse protocolo pode ser. E como nosso lema é: “Entenda para atacar”, vamos explorar o que é o LDAP, sua origem, a versão anterior, suas nuances e muito mais.

# O que é DAP e LDAP?

O **DAP (Directory Access Protocol)** foi um protocolo criado com base no X.500 (sobre o qual falaremos na seção de Diretórios) e no modelo OSI. Como sabemos, o modelo OSI não é amplamente utilizado na prática, sendo o TCP/IP o padrão dominante. Por conta disso, o DAP apresentava problemas de performance, pois era lento e pesado.

Para resolver essas limitações, surgiu o **LDAP**, com o termo *Lightweight* adicionado ao nome. Ele manteve o uso do X.500 para a estrutura de diretórios, mas passou a utilizar o TCP/IP como base. Isso o tornou mais leve, rápido e eficiente que seu antecessor, sendo utilizado até hoje.

# O que são os diretórios?

Como mencionado anteriormente, o LDAP utiliza o padrão **X.500** para a construção de seus diretórios. Esse padrão foi desenvolvido pela **ITU-T** (International Telecommunication Union – Telecommunication Standardization Sector). A ideia principal é que exista apenas uma **DIT (Directory Information Tree)**, onde todas as entradas são organizadas — como grupos, usuários, computadores, unidades organizacionais (OUs) e outros. Cada entrada contém os atributos e os valores correspondentes ao objeto representado.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXebZbjW8EiOHSlbrKWVFate-mVYBd-hcl_WXaZ7fI5yBmC5p3OLfUp9dZ44wHaHPZiPql6HY4svQtOndFldKJWy31RlSlZPPkQLXmflXs2B8h4KwuMSs3l2dVm_IPuY9wjlG9cR?key=88H8T1ieVFTabheQZtHW4A)

Nesta imagem, podemos perceber como o diretório é estruturado: ele se assemelha a uma árvore, tendo a hierarquia como base. O **DC=com** representa a raiz desse diretório, e tudo o que estiver abaixo são considerados seus “filhos”. Utilizando o usuário **D3v** como exemplo, podemos visualizar que os "parentes" desse objeto são, ascendentemente, **Pentest**, **hakai** e **com**.

Algo bastante comum nesse tipo de estrutura são os **DNs (Distinguished Names)**, que nos permitem identificar o caminho completo até um objeto dentro do diretório. Por exemplo:  
**DN: DC=com,DC=hakai,OU=Red Team,CN=Oliveira**. Com essa DN, sabemos exatamente onde o usuário **Oliveira** está localizado dentro da árvore.

Agora que entendemos o que é o LDAP e como funciona um diretório, uma dúvida natural pode surgir:  
**“O que podemos fazer com esse diretório e seus objetos?”**. Para responder essa pergunta, precisamos conhecer as operações do LDAP.

# Operações LDAP

Existem diversas operações que podem ser realizadas com o LDAP, conforme definido na [RFC 4511](https://datatracker.ietf.org/doc/html/rfc4511?ref=yokai.hakaisecurity.io), mais especificamente na seção **4.1.1 (Message Envelope)**.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXerpcIx1SegjmnN_JpMuJji9Sj-WJe38fbRrTOrmAkDmm9R2BHY6z65zJ_3BLcv7xEgym1oK2A-qCEeD1DDz1I38SVvtsVnq4aRbO84eCcPLovpBkpK8UCwLeingS2ZN6UZCNpOcg?key=88H8T1ieVFTabheQZtHW4A)

Neste post, comentaremos sobre as principais operações do LDAP: **Bind**, **Add**, **Delete**, **Modify** e **Search**.

## Operação Bind

A operação **Bind** é utilizada para a autenticação do usuário. Existem duas formas principais de autenticação: **Simple** e **SASL** (*Simple Authentication and Security Layer*). A autenticação está detalhada na **RFC 4511**, seção **4.2 (Bind Operation)**, onde é possível visualizar exatamente como essa operação é especificada.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcwawQ044xUSRG9qqpWpz8iOoruygoPuaEqPJ0LOP5VPOzwCv97-zmn4BZKbKQpW9ReeS1lyLQUIFLQzy7EM41sv51EJY8Ssc22FyVqgRQG4w7OX77jpAilfR56hla8iCVphgzW?key=88H8T1ieVFTabheQZtHW4A)

A **Simple Authentication**, como o nome sugere, é utilizada para autenticação básica, por meio de usuário e senha.

```bash
ldapsearch -H ldap://hakai.com -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "OU=Pentest,DC=hakai,DC=com"
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXehQtZSd-3Q5GZTRtVaS6Qgy7VbspF-IIxAjhCBntu7P1zt5W3V44sk2sT3I3RwQN9brjkwAfTI5-V7CzQbvRZ732_OKIH-2gSd_sZa1Gp8nlQNCrh2TRh4ICWCo9Cdm8Joe6ZygA?key=88H8T1ieVFTabheQZtHW4A)

Utilizando a ferramenta **ldapsearch** com a opção **\-x** (que ativa a *Simple Authentication*) e passando a flag **\-D** com o DN do usuário que será usado — neste caso, podemos utilizar **maxin@hakai.com** ou **CN=maxin,OU=Pentest,DC=hakai,DC=com** — estabelecemos uma conexão com autenticação simples.

A partir desse ponto, e para o restante deste post, utilizaremos o **Wireshark** para analisar a comunicação. No exemplo a seguir, veremos como a autenticação é realizada.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdpNQZntn_YrfSMzdPmIhKv42jjDDlTvTJjMarFrCPAZNZJdedWgj2gcmVavP5KKTQTtnurF47eJlZ4Kv53sCm_RfHvIV-kJna4GxsMFHIz9yCFtV1vzekSFjIuQQYbuZFRnZSf?key=88H8T1ieVFTabheQZtHW4A)

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXeRektuOzgrweAYdCXaRjnbB3TWVkqI5vB3qn2KE-bcUYD7PuVJ8s8h9MUIltGud-6idCm-T_r6OvXdgb-_0sqlHx9yAhN7WFHgtXtOoiwGfd6cwK1UhY0eXjrhXTKlYYeOlORfgg?key=88H8T1ieVFTabheQZtHW4A)

Diferentemente da **Simple Authentication**, o **SASL** é utilizado para autenticação por meio de protocolos externos, como o **GSSAPI**, que é empregado na autenticação Kerberos.

Para utilizar um protocolo externo no **ldapsearch**, usamos a opção **\-Y**.

```bash
ldapsearch -Y GSSAPI -H ldap://dc01.hakai.com -b "dc=hakai,dc=com"
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXd6glrnR8xYw59Zv0fnqy4owKTBRO7goVvOyekpkbUWoMcUngzPcDKRZEWmFApWUQBUJVQ53jaIrJUjEcM_i1RJ6ND2XOfKGuBAO0sYTwjtiLz3ytDx7ssw35kJe2sTlxGapZsBXg?key=88H8T1ieVFTabheQZtHW4A)

Podemos observar que, em comparação com a **Simple Authentication**, a comunicação utilizando um protocolo externo é muito mais complexa e requer o envio de uma quantidade maior de informações.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdPocyv6kUy_wTzwDObmP0ERKgCyy6vSCEOSIUfCktkDJUJDU5DM8X51x21CA9FQqY_8MAjN_uRmpankkBOmlu6TBVavT3D7xcg15fk0is1g61FB4YrfmUsyDfCn7z7CNAd0Up07w?key=88H8T1ieVFTabheQZtHW4A)

## Operação de Adição

A operação **Add** é utilizada para adicionar uma nova entrada no diretório. Podemos incluir usuários, grupos, computadores, entre outros objetos, dependendo das permissões do usuário que estiver realizando a ação.

Neste exemplo, adicionaremos uma nova máquina ao domínio. Para isso, é necessário criar um arquivo **LDIF** (*LDAP Data Interchange Format*), que será usado pelo comando **ldapadd**.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfqjXJ4wuoi3jvXau0Sjm7rj-PyPvMJ6-17h9_cVQV5TL4gK-IlfXtghrm2Rd_Aaxp0K2eAsTW5G5sugeb-bUncG7yktuRPyBiNT0H9rFH4MrR4k5FiFwrfrCFcMPqeyKWqHev50g?key=88H8T1ieVFTabheQZtHW4A)

Após criar o arquivo *LDIF*, podemos executar o **ldapadd**, utilizando um usuário com privilégios de administrador para realizar a operação.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcFJUXna4r_suaWJ7qNww4zDHcOlYPrbvQ1ojGQStoWTiyHJ8fUm6X2BBQqACiJL5-eGY9Rtg52iyekDe0dPOX83wJvc6Ox8zctFVnJIZED7RXKoiKyfSOb2_NBqwqH-UNYfYxfAg?key=88H8T1ieVFTabheQZtHW4A)

## Operação de Modificação

A operação **Modify** é utilizada para modificar entradas no diretório. Podemos alterar objetos no *LDAP* dependendo das permissões do usuário em questão. Assim como na operação **Add**, essa operação também é feita por meio de um arquivo **LDIF**.

Essa operação é muito importante, mas pouco utilizada. Caso seu usuário tenha permissão sobre outro usuário ou faça parte de um grupo especial, é possível usar a operação **modify** para alterar entradas no diretório *LDAP*. Por exemplo, se um atacante obtiver acesso a uma conta pertencente ao grupo **Account Operators**, poderá utilizar essa operação para adicionar usuários a outros grupos no *Active Directory*.

Neste exemplo, adicionaremos o usuário **Oliveira** ao grupo **Administrators**.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcpAdUKrXdcl2lu91moCyV5y04IVYzRteKPtMdROx2zXWGZIxkqGKOHpjaXSX0YJUjwI00h-fCjPI8w31Mg5B39BJygZP_4mqXhgaeQ-Kv76kMCXgIYsaVIO9qgxhf3LOkM-JGD_A?key=88H8T1ieVFTabheQZtHW4A)

Usaremos a ferramenta **ldapmodify** para realizar essa ação, passando o arquivo **LDIF** criado anteriormente.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXe4z24QZtpOEAENExPkt38_cJwUJ9irv8WDMQ2kxeaqCSx5Fu__Z1gS2CgF3PDJy6C6Q4maiuzm-beYZOqLN4F-JzfpiF27yWBF2zw-sCvhvaAoeCQ85wH-4jfhHJyyEckjPgpI?key=88H8T1ieVFTabheQZtHW4A)

## Operação de remoção

A operação **Delete** permite excluir uma entrada no diretório. Diferentemente das operações anteriores, o **Delete** não requer um arquivo **LDIF**, pois é uma ação direta onde especificamos o **DN** da entrada que será removida.

Neste exemplo, iremos excluir o computador criado anteriormente na operação **Add**.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXe5x8JwHeMIoyyVKIDyxJvGlbbdraQIwDHCeux349YEdjJrQwntPNl_5ODqIttiH0RvZi08S25ia63jBSylJ5yaNZCYULiptf400fOivMGu_HTT8b1bOufot1WDr6dKiQ11QUYlsQ?key=88H8T1ieVFTabheQZtHW4A)

# Operação de Busca

A operação **Search** é a mais utilizada no LDAP, permitindo pesquisar todas as informações do *Active Directory*.

Para entender a **Search Operation**, precisamos compreender os elementos necessários para sua construção. Na seção [4.5.1 (Search Request)](https://datatracker.ietf.org/doc/html/rfc4511?ref=yokai.hakaisecurity.io#section-4.5.1) da **RFC 4511**, vemos exatamente como ela é definida.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXeyat6CD7Nu1fj40YbmOV2BdyAZGwYle-GJuuX3ATaxXczwb15xYzESKRf6rM2tuFssYd1jzuayHB67nMCKP4iqyirBycJ_xaKJ0YTfIDZzCyv4AT701o1jhn2HRDxXzc03A8hWTA?key=88H8T1ieVFTabheQZtHW4A)

Essa operação é dividida em vários componentes: **baseObject**, **scope**, **derefAliases**, **sizeLimit**, **timeLimit**, **typesOnly**, **filter** e **attributes**. Neste post, focaremos nos elementos **baseObject**, **scope**, **filter** e **attributes**.

## Base Object & Scope

O **base object** define o ponto na “árvore” a partir do qual a pesquisa começará. Por exemplo, se definirmos o base object como `OU=Pentest,DC=hakai,DC=com`, todas as informações coletadas serão a partir da unidade organizacional (OU) **Pentest**. Nesse caso, a pesquisa não retornará dados relacionados a outras OUs.

Geralmente, o base object é definido no topo da “árvore”, como **DC=hakai,DC=com**, para que a pesquisa colete todas as informações possíveis.

Já o **scope** determina o quão profundo iremos a partir do ponto definido pelo base object — por isso, os dois conceitos se complementam. Como mostrado na imagem anterior, o scope possui três opções:

- **baseObject (0)**
- **singleLevel (1)**
- **wholeSubtree (2)**

Cada uma dessas opções define o nível de profundidade da pesquisa. Para ilustrar melhor, observe a seguinte imagem:

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfrk--mO9MihW2NTsjOu4ABm0CMAQZMEIFd1NCFdmP0oK335NsI02GDTnKGY0wPjAaUU_ZRqIUODTb_Z2TR4KB_zs6t5blh7zkF7_jZiLHEIxStWzl9qWR8gkU12jK6TR28ZgJybw?key=88H8T1ieVFTabheQZtHW4A)

Neste caso, definimos o **baseObject** como **DC=hakai,DC=com**.

Se definirmos o **scope** como **baseObject** (destaque em vermelho), o escopo se limita exatamente ao ponto base definido. Ao escolher **singleLevel** (destaque em azul), o *scope* abrange apenas um nível abaixo do *baseObject*. A última a opção **wholeSubtree** (destaque em verde) permite visualizar toda a árvore a partir da base definida.

A opção mais utilizada para o escopo costuma ser a **wholeSubtree**, mas é importante conhecer todas as opções disponíveis. Neste exemplo, usaremos novamente o **ldapsearch**, mas agora sem definir explicitamente o escopo.

```bash
ldapsearch -H ldap://hakai.com -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" "objectClass=user" cn
```

Podemos observar no *Wireshark* que as informações enviadas correspondem exatamente ao que a RFC específica.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcV-GEeIOOFtukwdMW18HJPcyimtm8Wx531kdTc0QQbrVUsS-e6E1ZFmLgULt_IPrDhD_0zFItbS3tEH3vU8_mvJ8o6bc5JKbkrEu4GOzBh3ndS2p-oK7P9BKUidEr654wk48D7Yg?key=88H8T1ieVFTabheQZtHW4A)

No comando **ldapsearch**, a opção **\-b** define o **baseObject** e a opção **\-s** define o **scope**. Como não passamos nenhum valor para o escopo, por padrão é utilizado o **wholeSubtree**, conforme mostrado na imagem.

## Attributes & Filter

### Attributes

Nesta seção, começaremos falando sobre os atributos, que são a base para entender os filtros no LDAP.

Todos os objetos no *Active Directory* possuem atributos. Para visualizar esses atributos, podemos realizar uma busca simples usando o **ldapsearch**.

```bash
ldapsearch -H ldap://hakai.com -LLL -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" "cn=maxin"
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXd-g5A2IoavCPOosgdfiWZxoWDJj0UIEpkuGnzawEzfvdGRH_4cCS9BMupgHmgDhxSD41YqTpUnGuPQ5WF6M5bEGO8T_OwL709oPhToTZOHOjYaQelx6bm21jZWfvFUfi3IMLwH8g?key=88H8T1ieVFTabheQZtHW4A)

A seguir, apresentamos alguns atributos do objeto **maxin**. Com base nesses atributos, podemos aplicar o que chamamos de **Attribute Selection** para filtrar quais informações queremos visualizar. É importante destacar que, no comando **ldapsearch**, a seleção dos atributos deve ser feita na parte final do comando.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcfErqOqcwV7rq30YK59fQfuM1gSbTuokDkW227oZDTtZ63Dpz29wh4nq_Wy9ZJS_tJk2FZkANN5mIZjJe0bDw1sEZlMmAB9AAhFJEZJm9hxmRVJ6kpxh5RZDIbpS3ps_6-jZJ7?key=88H8T1ieVFTabheQZtHW4A)

Capturando essa pesquisa feita no *LDAP* via *wireshark*, podemos ver os atributos selecionados.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcFpPtTmRvzoDDF_SLeXe7Bkp9OOlIpBm4YX_tSZGmy63iHSmqi6_f5HhLjW2MiYe0LppgfqVwwlNzVWFArtTcm04frUzT2TnBoJrD5pOnlYli-hjfHuFHUQjfMLS1y2Ujrh_I8?key=88H8T1ieVFTabheQZtHW4A)

É interessante entendermos o que acontece quando fazemos uma pesquisa simples no *LDAP* sem definir explicitamente o **Filter** e o **Attribute Selection**.

```bash
ldapsearch -H ldap://hakai.com -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com"
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdNHX7Evq2eCb00HJdjcaL24m7owClt0rYtmrTFY9C-C-9wIFWg0cMG6T4KIwSetC0kTtzjJllX6VeidMdAHrA4RQyWg0jPyGN5Dzy646_BqaUbU-Koh1PL5z0LykWF4hJfvO_Q?key=88H8T1ieVFTabheQZtHW4A)

Caso nenhum filtro seja especificado, o **ldapsearch** utiliza, por padrão, o filtro `objectClass=*`. Isso significa que a busca retorna todas as classes de objetos presentes no Active Directory, ou seja, praticamente todos os objetos. Já o campo **attributes**, quando definido como `0`, é interpretado como `*`, o que faz com que todos — ou quase todos — os atributos dos objetos selecionados pelo filtro sejam retornados.

Agora que entendemos o funcionamento básico do **Attribute Selection**, podemos avançar para o **Filter**. Nas operações de **search**, o filtro é um dos elementos mais importantes, pois determina exatamente quais tipos de informações serão coletadas. E esse filtro é baseado nos atributos dos objetos.

### Filter

Consultando novamente a **RFC 4511**, na parte referente aos filtros, encontramos algo bastante interessante.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfczkf8d23Pt9JN2koO9GhNUDDkGnQslFYgi9okNVreBjIgJeQFsYEV6vHDqUkpSce7NfnqxujgvtoRs-3QWia3AE_rc0GkFJIcCNp_51cN-aoxmftzixb6ldaEFpceFnlqsyXn?key=88H8T1ieVFTabheQZtHW4A)

A RFC define diversos tipos de filtro, incluindo os chamados **operadores booleanos** — **AND (0)**, **OR (1)** e **NOT (2)** — sobre os quais falaremos mais adiante neste post. Além deles, temos outros filtros como:

- **equalityMatch (3)**
- **substrings (4)**
- **greaterOrEqual (5)**
- **lessOrEqual (6)**
- entre outros.

Para entender melhor como cada tipo de filtro funciona, comecemos por um dos mais básicos: o **equalityMatch (3)**.

No exemplo a seguir, iremos filtrar todos os objetos cujo atributo **CN** seja igual a **"maxin"**. Como existe apenas um objeto com esse nome, o retorno será único — o próprio objeto *maxin*.

```bash
ldapsearch -H ldap://hakai.com -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" "cn=maxin"
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfoDg3aRg6n4YWAjuspG-uMZSfTzuqccEbKXLf83bpMO3yzBsYrQouropY9bBdhi9dd6dF5cVDGIwB-vvRhwsu186iEWJq5fUPoDgZ2hWzswmcEGFOhN4aCeA5Nt8PCKVOZxgDsKg?key=88H8T1ieVFTabheQZtHW4A)

Ao capturar essa operação no *Wireshark*, podemos ver exatamente o que a RFC descreve: a utilização do **equalityMatch (3)**, o campo **attributeDesc** (que indica qual atributo está sendo filtrado) e o **assertionValue** (o valor definido na consulta).

Outro tipo de filtro bastante útil é o **substrings (4)**. Um exemplo prático seria:**` cn=ad*`**. Neste caso, estamos utilizando o atributo **CN** com um curinga (`*`) para buscar todos os objetos cujo nome comece com **“ad”**. Embora este exemplo use o atributo *CN*, o **substrings** pode ser aplicado com diversos outros atributos conforme a necessidade.

```bash
ldapsearch -H ldap://hakai.com -LLL -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" "cn=ad*" cn
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcWmb_fSopaUos0UBI2UGRpKYNgIt63p9vOZSgIu9tbmzE95eFS15UIWCr9rGty5JiAa4i7f66-U8-j0LB5tnFKXt5jcOuLNBOq_k7tel1BPYlQQMuQMHbmQTdfkWg7KvgPc-ppKw?key=88H8T1ieVFTabheQZtHW4A)

Esse filtro nos retornará todos os objetos cujo **CN** comece com “ad”. É importante observar que o Windows (e, por consequência, *o Active Directory*) é **case insensitive**, ou seja, não diferencia letras maiúsculas de minúsculas. Por isso, nomes com letras maiúsculas aparecerão no resultado.

Ao capturar essa operação no **Wireshark**, conseguimos visualizar claramente como a busca foi realizada.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdIG_aWBv_8VHSdsCakpZjJB28-KhBrObDaJiyy_CzyPPWFsmASppCpRMl7WIIlBsZwsRXAaQskFFVyLynqUXwSLnQp0tbJSLDWIr8FiT0UoUQtzUJ7Y7hpm2xRTTQ1i1A77g-NnA?key=88H8T1ieVFTabheQZtHW4A)

Existem dois filtros adicionais que merecem destaque: **greaterOrEqual (5)** e **lessOrEqual (6)**. Vamos entender como eles funcionam e como podem ser utilizados em consultas mais avançadas.

Ambos seguem o mesmo padrão de uso, é necessário fornecer um valor como **número**, **letra** ou **símbolo**.

```bash
ldapsearch -H ldap://hakai.com -LLL -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" "cn>=a" cn
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdyh-hZNOcQs18evkQy7s-PUlzLbGEqnjStxnmstpW0FYgyFPg7QBieeB6z5xQt8wY0ZAIGbDzKUmkUTC1DWMkbJamlEspbBtjTB-5LWk7WyNVPpnd7tbFLYOUCnh65ULj3OEoA?key=88H8T1ieVFTabheQZtHW4A)

O que exatamente o **greaterOrEqual** está fazendo nesse caso? Ao utilizarmos esse filtro com a letra **“a”**, o *LDAP* converte essa letra para o valor **97**, que é seu código decimal na **tabela *ASCII***. A partir disso, ele retorna todos os objetos cujos atributos comecem com **97 em diante** — ou seja, **a**, **b** (98), **c** (99), **d** (100) e assim por diante. Quanto **menor** o número fornecido (em termos de *ASCII*), **maior** será o alcance da busca.

Neste próximo exemplo, utilizamos o símbolo **“!”**, que corresponde ao número **33** na tabela ASCII. Essa consulta retornou **711 linhas**, em comparação com o exemplo anterior, onde usamos a letra **“a”** (valor 97 na tabela *ASCII*) e obtivemos apenas **455 linhas**. Isso demonstra como valores mais baixos na tabela *ASCII* ampliam o escopo da busca. 

```bash
ldapsearch -H ldap://hakai.com -LLL -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" "cn>=!" cn
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfIN6riNkVtBj4xTafvPy28022HK50YO5rf6Fgw6mwsShUW2ZNngkSzHvaGZKh-3De-spIEEoZMa87dxIjy6_TVfbeh32aa_CH_845mUiiDQSkJWdeHYsb2v5-dW1EZ9Xj4Q8Sl3Q?key=88H8T1ieVFTabheQZtHW4A)

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXeeXJ8PJDMmLxDIPle0o9akLpWWhRMkAStR58EkUCxH5HtXAyHXdRW36jSQ6uRK7NgZVLjTWflwNuYpxu5dSx4gXb1tYr-3jjacHwQuQdlf4cAGfqPcfCBHa3QRaAgsKt29hwpxrQ?key=88H8T1ieVFTabheQZtHW4A)

Entendendo o funcionamento do **greaterOrEqual**, o uso do **lessOrEqual** torna-se uma consequência lógica, já que ambos seguem o mesmo padrão de operação. O "truque" agora é inverter a lógica: utilizar uma letra ou símbolo com um valor **alto** na tabela *ASCII*, para limitar os resultados — ou seja, fazer o caminho inverso e filtrar apenas objetos com valores **menores ou iguais** ao definido.

```bash
ldapsearch -H ldap://hakai.com -LLL -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" "cn<=a" cn
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdpm-JWTzYGE9tqsClA2HmkcJJKrYyHXPT3233ck0i9p7O0RUBP0IgNGVA_fpHaV7asheaYeOnFgErXmLTHUz5dwUbEe6IMCcuRe92jIFFpoNClspbeAM9V7CdqDU53i0BNWPvQXg?key=88H8T1ieVFTabheQZtHW4A)

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdNb5ZpiRPKJyBQn4R7T1rgzpZXl4Gb_xPBZKqtWwejO3nxhL4Q9anK1HRxYeGVaeAwYM_Xn47hEiSi3RXq0Q4zaPTOnn-k9DE-QRQ3HEVp-6g1XX-b_xDMiVzye4lV4u_Hm-erXA?key=88H8T1ieVFTabheQZtHW4A)

### Search Extensions

Como mencionado anteriormente, o **ldapsearch**, por padrão, não retorna todos os atributos disponíveis dos objetos. Por exemplo, o atributo **ntSecurityDescriptor** é extremamente importante, pois contém informações sobre **DACL** e **SACL**, que definem permissões e auditorias. No entanto, se tentarmos buscá-lo diretamente, como no exemplo abaixo:

```text
"cn=maxin" ntSecurityDescriptor
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXf5s87mM1bOzGwMivjHS6PsAAwIp9moekhKhkExtEAom60GGmUAqk7ExxMb0lJQjBV_2JfsCcpp26KXnUK77hiVzN7uuzOWMjf48oVEh2Er9Oa5WYRNwrzuD8w_n38QShj-XgDT?key=88H8T1ieVFTabheQZtHW4A)

Não teremos nenhum retorno para esse atributo. Mas isso **não significa** que ele não possa ser acessado.

Para isso, utilizamos uma funcionalidade chamada **Search Extensions** no **ldapsearch**, ativada com a flag **`-E`**.

```bash
-E '1.2.840.113556.1.4.801=::MAMCAQc=' 'cn=maxin' ntSecurityDescriptor
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXew4Hq_vVcI9ac78ln-Zxdu-VoALbBvnJud1y1oesOHFpy8XNDw4d9wOqSDcGEVW3lD67FLbcLLCt9-2wGuuF8aG4uUOsTNUd5yev5liQ2O1QU7iuLEWaDWSnX7hW3fJXlZbGSvbQ?key=88H8T1ieVFTabheQZtHW4A)

Vamos por partes para entender o motivo pelo qual essa busca funciona. A opção de **Search Extensions** aceita apenas **OIDs (Object Identifiers)**. O OID **`1.2.840.113556.1.4.801`** é interpretado como uma extensão chamada **SD\_FLAGS**.

O **SD\_FLAGS** define quais partes do **ntSecurityDescriptor** serão retornadas. Os principais componentes e seus valores são:

- **DACL (Discretionary Access Control List)**: `1`
- **SACL (System Access Control List)**: `2`
- **Owner**: `4`
- **Group**: `8`

Se quisermos retornar **DACL**, **SACL** e **Owner**, precisamos somar os valores: `1 + 2 + 4 = 7`. O valor **`MAMCAQc=`** que aparece na extensão é um **blob em base64** que representa exatamente esse número (`7`), porém codificado e seguindo a estrutura **ASN.1**, exigida pelo **SD\_FLAGS**.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfuvAriHqvjKs_rwJlwASbz9RRD4m3ZenaE66Wigtgk7mDSnVQ7JR1ZHA8kWfxCasxi3NUgYIYPcU40X8Dx-wyrvxoFOjtBpYplu7RlqBXg4jkf7_tFacP1XgAJtcTXP8UoyXVb?key=88H8T1ieVFTabheQZtHW4A)

### Operações booleanas

As operações booleanas no *LDAP* permitem construir filtros mais complexos e específicos, utilizando os operadores **AND**, **OR** e **NOT**. Vamos entender melhor como cada um deles funciona na prática.

A operação **AND** é representada pelo símbolo **`&`**. Assim como a operação **OR** (que veremos a seguir), é necessário combinar **duas ou mais condições**, cada uma envolvida por parênteses. A estrutura fica assim: **&(condição1)(condição2)**.

Neste exemplo, realizamos uma verificação simples. Aqui estamos verificando se o objeto pertence à classe **user** *e* se o **CN** é igual a **maxin**. Ambas as condições precisam ser verdadeiras para que o objeto seja retornado.

```bash
ldapsearch -H ldap://hakai.com -LLL -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" '(&(objectClass=user)(cn=maxin))'
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdhx0Z6EqvazPTudiwMk0lhMKI8yGIHjrUsdUNrh8sfFRX76vPLjcpd9jrBEfiLrzIq5yetCWtQGkcZvWIhtJUYsLxt9-x9ybflutoHl-y5vA0Ei8f7y7pmqU8JUt4IacGIvzCu?key=88H8T1ieVFTabheQZtHW4A)

Podemos melhorar esse filtro utilizando o que aprendemos na seção anterior, com o operador **greaterOrEqual**. Estamos verificando todos os objetos da classe *user* que retornam na busca de **“cn>=!”**. 

```bash
ldapsearch -H ldap://hakai.com -LLL -x -D "maxin@hakai.com" -w "P@ssw0rd" -b "DC=hakai,DC=com" '(&(objectClass=user)(cn>=!))'
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXe_fNS8EaeDV4cTXlX8DccehhRpWTWAVu4dU9DlBGTQnDrdaUrE3mi2bJ4zCTbDn5GL6Dqompt3ma0fX9kHe1ISdRNcO2tXvEYxMu4Kd3Z6JDx9jLUimbAvRUElV8exggLCXo3M4w?key=88H8T1ieVFTabheQZtHW4A)

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXepKUg2-l_sSe_zj1v8cj3sgIoqj1BsxUgy_MZP_jFzOZgx-VDrAMpnZCEiRf1DdurazFZ4mdaJ49_A_LzDWjwOXosLMW5vhGBCBUpOoXGj8ZoD_XfV8IkoHjHj1T1w0aI7eo_qQQ?key=88H8T1ieVFTabheQZtHW4A)

A operação **OR** segue a mesma estrutura do **AND**, mas com uma diferença fundamental: **basta que uma das condições seja verdadeira** para que o objeto seja retornado.

Para utilizar o **OR**, usamos o símbolo "`**|**"`, da seguinte forma: **|(condição1)(condição2)**. Normalmente, o *OR* é combinado com outras operações booleanas para compor filtros mais precisos. Por exemplo:

```text
'(&(objectClass=user)(|(cn=maxin)(cn=luriel)))'
```

Neste caso, utilizamos um **AND** em conjunto com um **OR**. Veja que, após a condição **(&(objectClass=user)**, abrimos outro parêntese — esse contém a operação **OR**, com duas condições internas. Aqui, como ambas as condições dentro do *OR* são verdadeiras (os CNs **maxin** e **Luriel** existem) e a condição do *AND* também é satisfeita, os dois objetos são retornados.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdHQsfhScdRYIfhzTfst-Cuy_gs0qQc1epK4PHzVIPG2O0qPgdqJNhc9PJ2BnyttVupIyT6TW5Hg5TxcOjHsH5kfWYFwXLTzs73CE2iH7gIvlBlQ4vdgCcpRA_1X2okkAHAItomzQ?key=88H8T1ieVFTabheQZtHW4A)

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXflFMOUTg_yvLT0aua-LDlsVyy5gfLX_ZsUykOyCM05kK2z5wC5bOvKjHCI1XR0zH6-Jxp8uf4M5RBT2IZQON8N_3AzY2jgIfLymAd2FG7Cxa4n0l1EyUsiMPXTCNNxQjYWFmhzhg?key=88H8T1ieVFTabheQZtHW4A)

Ao analisar essa busca no **Wireshark**, podemos observar um padrão interessante: o filtro começa com o **AND (0)**, e dentro dele há um **OR (1)** — exatamente como foi estruturado no comando. Isso mostra claramente como o filtro é interpretado pelo *LDAP*.

A operação **NOT**, representada pelo símbolo "`**!**"`, é a última operação booleana disponível no LDAP. Como o nome sugere, essa operação **nega** a condição fornecida. Diferentemente do **AND** e do **OR**, o **NOT** requer **apenas uma única condição**, ou seja, apenas **um par de parênteses** é necessário.

Neste comando, estamos buscando todos os objetos da classe **user** que **não** tenham o **CN=maxin**. O resultado será uma lista com todos os usuários, exceto o objeto **maxin**.

```text
'(&(objectClass=user)(!(cn=maxin)))' cn
```

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXeypHNQQBOm5WQ4Nll2OOJulLp6uFbzCuafkKpu9Jks14EWkRUh0Ya6Q3JZZbzcw2Sxh7K3fm4gWlIVGdzXcJE7zf5HTDDhl9p80MdgG_hyd8ZuaCHm89QZkPFuwoBbkhu3CcevXA?key=88H8T1ieVFTabheQZtHW4A)

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdo0BFBwv6ZjAEIyPq_ndPQeaXKLo53aH0au3bY76izYF4fgt_reCvXGmC6R7pHFpHB1tnAYnqU4ai8ycwReSVxxfb8iZi7hs2nYL1eWDxEpSD01mpFz5x9irtMqix_dSBjms_IqA?key=88H8T1ieVFTabheQZtHW4A)

Na imagem acima, podemos visualizar claramente no **Wireshark** a presença da operação **AND (0)** e, dentro dela, a operação **NOT (2)** aplicada à condição.

Esses foram exemplos simples para demonstrar o uso dos **Boolean Operators** no LDAP. Apesar da simplicidade dos casos apresentados, essas operações têm uma aplicação muito mais ampla, especialmente quando integradas a mecanismos de autenticação **web-based**, onde podem ser usadas para construir ou manipular lógicas de acesso com base em filtros *LDAP*.

# Conclusão

Quando nos deparamos com um ambiente de **Active Directory**, entender o funcionamento do **LDAP** é essencial. Mesmo que não o utilizemos diretamente, ele quase sempre está atuando nos bastidores. Por isso, conhecer o protocolo, saber como ele opera e como extrair informações de forma consciente é de extrema importância. Ferramentas amplamente utilizadas como o **BloodHound**, por exemplo, fazem uso intensivo do *LDAP* para coletar dados e realizar correlações — como o atributo **ntSecurityDescriptor**, citado anteriormente, que permite identificar permissões entre objetos e o que um usuário pode ou não fazer no domínio. Outro exemplo é o **Certipy**, utilizado no reconhecimento e exploração de vulnerabilidades no **Active Directory Certificate Services (AD CS)**. Assim como o *BloodHound*, o *Certipy* também utiliza o *LDAP* para buscar e estruturar informações críticas.

Esses exemplos deixam claro o quão poderoso é o protocolo. Embora seja comumente lembrado apenas por sua função de pesquisa, o *LDAP* permite também **adicionar**, **modificar** e **remover** entradas no diretório — funcionalidades que, se mal utilizadas ou exploradas, podem comprometer seriamente um ambiente.

**Ressaltamos sempre a importância de entender como os sistemas — protocolos, serviços etc. — realmente funcionam para, só então, atacá-los.** Nada adiantará se não entendermos o que está acontecendo e simplesmente tentarmos atacar. Nesse cenário, acabamos apenas executando ferramentas sem compreender o que de fato está acontecendo — e, provavelmente, sem obter nenhum resultado relevante. **Entenda primeiro e ataque depois!**

**Espero que este blog post tenha lhe ajudado, de alguma forma, a entender mais sobre o protocolo LDAP e tudo o que realmente pode ser feito com ele.** Além disso, este *post* também foi uma forma de mostrar como a curiosidade e a vontade de entender podem levar a uma compreensão significativa sobre qualquer tema. Espero que esta demonstração sirva como um combustível para todos que estão lendo e incentive a fazer o mesmo.