# Técnicas Avanzadas de Evasión en PowerShell, Análisis y Contramedidas

- Link: https://binariocero.com/windows/tecnicas-avanzadas-de-evasion-en-powershell-analisis-y-contramedidas
- Published: 2025-11-26T16:41:22+01:00
- Author: Binario 0

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

PowerShell es una herramienta extremadamente poderosa para la administración de 
sistemas Windows… y precisamente por ello también es uno de los vectores favoritos
de los atacantes. Conocer las técnicas de evasión más utilizadas permite reforzar
la seguridad, mejorar la monitorización y diseñar reglas defensivas más efectivas.

A continuación se analizan varias técnicas empleadas para ocultar actividad maliciosa,
junto con su impacto y las medidas recomendadas para mitigarlas.

## 1. Uso de _Alternate Data Streams_ (ADS) para Evasión

    ```wp-block-code
    $content = 'Invoke-Mimikatz'; $file = 'C:\temp\normal.txt'; $stream = 'C:\temp\normal.txt:hidden'; Set-Content -Path $file -Value 'This is a normal file'; Add-Content -Path $stream -Value $content; Get-Content -Path $stream
    ```

Los _Alternate Data Streams_ de NTFS permiten almacenar información oculta dentro
de un archivo sin modificar su contenido visible. Un atacante puede esconder comandos,
cargas maliciosas o scripts dentro de estos flujos alternativos.

**Riesgos principales**

 * El contenido no aparece en un listado normal del sistema de archivos.
 * Muchos antivirus no inspeccionan ADS por defecto.
 * Permite persistencia discreta.

**Cómo defenderse**

 * Utilizar herramientas específicas (Sysinternals `streams.exe`, PowerShell `Get-
   Item -Stream *`).
 * Monitorizar rutas sensibles mediante EDR.
 * Bloquear ejecución desde rutas no aprobadas.
 * Analizar cambios inesperados en archivos aparentemente benignos.

## 2. Bypass de la _Execution Policy_

    ```wp-block-code
    $policy = Get-ExecutionPolicy; Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process; # Run your
    script here; Set-ExecutionPolicy -ExecutionPolicy $policy -Scope Process
    ```

Algunos atacantes modifican temporalmente la Execution Policy del proceso para permitir
la ejecución de scripts que normalmente el sistema bloquearía.

**Riesgos**

 * Permite ejecutar scripts no firmados o potencialmente maliciosos.
 * No deja rastros persistentes si solo se modifica a nivel de proceso.

**Contramedidas**

 * Aplicar políticas de restricción mediante GPO que no puedan ser sobrescritas 
   fácilmente.
 * Monitorizar procesos de PowerShell con parámetros sospechosos.
 * Habilitar el _Constrained Language Mode_.
 * Forzar la firma de scripts corporativos.

## 3. Ejecución de Scripts en Memoria (_In-Memory Execution_)

    ```wp-block-code
    $code = [System.IO.File]::ReadAllText('C:\temp\script.ps1'); Invoke-Expression $code
    ```

Los atacantes pueden cargar y ejecutar código directamente en memoria sin escribirlo
al disco, evadiendo soluciones basadas en escaneo de archivos.

**Riesgos**

 * Evita firmas tradicionales basadas en archivos.
 * Se combina habitualmente con payloads cifrados o comprimidos.

**Medidas defensivas**

 * Activar y revisar _PowerShell Script Block Logging_.
 * Implementar AMSI (Antimalware Scan Interface) y asegurarse de que no esté paralizado
   o manipulado.
 * Utilizar EDR con capacidades de monitoreo en memoria.

## 4. Invocación Dinámica mediante _Reflection_

    ```wp-block-code
    $assembly = [Reflection.Assembly]::LoadWithPartialName('System.Management'); $type =
    $assembly.GetType('System.Management.ManagementObjectSearcher'); $constructor =
    $type.GetConstructor(@([string])); $instance = $constructor.Invoke(@('SELECT * FROM Win32_Process'));
    $method = $type.GetMethod('Get'); $result = $method.Invoke($instance, @())
    ```

La reflexión permite manipular clases del .NET Framework sin cargar módulos visibles
o comunes, dificultando la trazabilidad.

**Riesgos**

 * Permite ejecutar funciones del sistema sin depender de cmdlets auditables.
 * Puede cargar ensamblados directamente desde memoria.

**Defensa**

 * Revisar logs de _event tracing for Windows (ETW)_ centrados en .NET.
 * Monitorizar uso atípico de métodos de reflexión.
 * Bloquear PowerShell clásico en favor de PowerShell 7 cuando sea posible, debido
   a mejoras de seguridad.

## 5. Ejecución de Comandos Codificados (Base64)

    ```wp-block-code
    $encodedCmd = [Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes('Get-Process'));
    powershell.exe -EncodedCommand $encodedCmd
    ```

El uso de comandos codificados oculta la intención real del comando, dificultando
la detección en registros básicos.

**Riesgos**

 * Oculta cadena real del comando.
 * Se usa habitualmente con `-EncodedCommand`.

**Cómo protegerse**

 * Configurar el logging avanzado de PowerShell.
 * Crear reglas de detección que alerten ante comandos codificados.
 * Implementar inspección de parámetros en soluciones SIEM/EDR.

## 6. Runspaces para Evasión

    ```wp-block-code
    $runspace = [runspacefactory]::CreateRunspace(); $runspace.Open(); $pipeline =
    $runspace.CreatePipeline(); $pipeline.Commands.AddScript('Get-Process'); $results = $pipeline.Invoke();
    $runspace.Close(); $results
    ```

Los _runspaces_ permiten ejecutar código en entornos paralelos que no heredan las
mismas restricciones del PowerShell principal.

**Riesgos**

 * Permite cargarse fuera del entorno monitorizado.
 * Reduce visibilidad en herramientas de análisis en tiempo real.

**Contramedidas**

 * Supervisión continua del comportamiento del proceso `powershell.exe` y `pwsh`.
 * Uso de EDR capaz de detectar runspaces y pipelines internos.
 * Deshabilitar versiones antiguas de PowerShell.

# Conclusión

Las técnicas descritas de ocultación en ADS, manipulación temporal de políticas,
ejecución en memoria, reflexión dinámica, comandos codificados y uso de runspaces
forman parte del repertorio estándar de TTPs avanzadas utilizadas por actores maliciosos.
Conocerlas es esencial para adoptar medidas de detección y endurecimiento adecuadas.

Fortalecer el entorno implica:

 * registrar todo lo posible,
 * utilizar soluciones EDR modernas,
 * aplicar políticas estrictas,
 * monitorizar el comportamiento más que las firmas.