Segurança dos Serviços do Windows: Guia Completo

A proteção dos serviços do Windows é um aspecto crucial da cibersegurança. Este guia explora técnicas avançadas de proteção e gerenciamento de serviços.

1. Gerenciamento de Serviços

Configuração Básica

# Desativação dos serviços não essenciais
sc config RemoteRegistry start= disabled
sc config Telnet start= disabled
sc config TFTP start= disabled

# Configuração das permissões
sc sdset RemoteRegistry D:(A;;CCLCSWRPWPDTLOCRRC;;;SY)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;BA)(A;;CCLCSWLOCRRC;;;IU)(A;;CCLCSWLOCRRC;;;SU)

Serviços Críticos

# Identificação dos serviços críticos
$criticalServices = @(
    "RemoteRegistry",
    "Telnet",
    "TFTP",
    "SNMP",
    "IISADMIN",
    "W3SVC"
)

# Desativação segura
foreach ($service in $criticalServices) {
    if (Get-Service $service -ErrorAction SilentlyContinue) {
        Stop-Service $service
        Set-Service $service -StartupType Disabled
    }
}

2. Proteção das Permissões

Configuração das ACLs

# Configuração das permissões dos serviços
$servicePath = "C:\Windows\System32\services.exe"
$acl = Get-Acl $servicePath
$rule = New-Object System.Security.AccessControl.FileSystemAccessRule("Administrators","FullControl","Allow")
$acl.SetAccessRule($rule)
Set-Acl $servicePath $acl

# Proteção das pastas de serviços
$serviceFolders = @(
    "C:\Windows\System32\drivers",
    "C:\Windows\System32\config",
    "C:\Windows\ServiceProfiles"
)

foreach ($folder in $serviceFolders) {
    $acl = Get-Acl $folder
    $acl.SetAccessRuleProtection($true, $false)
    Set-Acl $folder $acl
}

Gerenciamento de Direitos

# Configuração dos direitos de serviço
$serviceRights = @{
    "SeServiceLogonRight" = "SERVICE_LOGON"
    "SeAssignPrimaryTokenPrivilege" = "ASSIGN_PRIMARY_TOKEN"
    "SeIncreaseQuotaPrivilege" = "INCREASE_QUOTA"
}

# Aplicação dos direitos
foreach ($right in $serviceRights.GetEnumerator()) {
    $policy = New-Object System.Security.Principal.NTAccount("NT AUTHORITY\SYSTEM")
    $privilege = [System.Security.Principal.Privilege]::$($right.Value)
    $policy.AddPrivilege($privilege)
}

3. Monitoramento dos Serviços

Vigilância Ativa

# Script de monitoramento dos serviços
function Monitor-Services {
    $services = Get-Service | Where-Object {$_.Status -eq "Running"}
    foreach ($service in $services) {
        $process = Get-Process -Name $service.Name -ErrorAction SilentlyContinue
        if ($process) {
            Write-Host "Service: $($service.Name) - PID: $($process.Id) - CPU: $($process.CPU) - Memory: $($process.WorkingSet64/1MB) MB"
        }
    }
}

Detecção de Anomalias

# Script de detecção de anomalias
function Detect-ServiceAnomalies {
    $baseline = @{
        "svchost.exe" = @(100, 200)  # Faixa de PIDs normal
        "services.exe" = @(500, 600)
    }
    
    $current = Get-Process | Where-Object {$_.ProcessName -in $baseline.Keys}
    foreach ($proc in $current) {
        if ($proc.Id -lt $baseline[$proc.ProcessName][0] -or $proc.Id -gt $baseline[$proc.ProcessName][1]) {
            Write-Host "Anomalie détectée: $($proc.ProcessName) avec PID $($proc.Id)"
        }
    }
}

4. Proteção contra Ataques

Detecção de Serviços Maliciosos

# Script de detecção de serviços maliciosos
function Detect-MaliciousServices {
    $suspiciousPatterns = @(
        "cryptominer",
        "miner",
        "botnet",
        "backdoor"
    )
    
    $services = Get-Service
    foreach ($service in $services) {
        foreach ($pattern in $suspiciousPatterns) {
            if ($service.DisplayName -match $pattern -or $service.Name -match $pattern) {
                Write-Host "Service suspect détecté: $($service.Name)"
            }
        }
    }
}

Proteção contra Injeção

# Configuração da proteção contra injeção
$protectionSettings = @{
    "EnableLUA" = 1
    "EnableVirtualization" = 1
    "EnableInstallerDetection" = 1
}

foreach ($setting in $protectionSettings.GetEnumerator()) {
    Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System" -Name $setting.Key -Value $setting.Value
}

5. Auditoria e Logging

Configuração da Auditoria

# Ativação da auditoria dos serviços
auditpol /set /category:"System" /success:enable /failure:enable
auditpol /set /category:"Security" /success:enable /failure:enable

# Configuração dos logs
wevtutil sl System /maxsize:4294967296 /retention:true
wevtutil sl Security /maxsize:4294967296 /retention:true

Análise dos Logs

# Script de análise dos logs de serviços
function Analyze-ServiceLogs {
    $events = Get-EventLog -LogName System -Source "Service Control Manager" -After (Get-Date).AddHours(-24)
    foreach ($event in $events) {
        if ($event.EntryType -eq "Error" -or $event.EntryType -eq "Warning") {
            Write-Host "Problème détecté: $($event.TimeGenerated) - $($event.Message)"
        }
    }
}

6. Manutenção e Atualizações

Gerenciamento de Atualizações

# Script de atualização dos serviços
function Update-Services {
    # Verificação das atualizações do Windows
    $updateSession = New-Object -ComObject Microsoft.Update.Session
    $searcher = $updateSession.CreateUpdateSearcher()
    $searchResult = $searcher.Search("IsInstalled=0")
    
    if ($searchResult.Updates.Count -gt 0) {
        $installer = $updateSession.CreateUpdateInstaller()
        foreach ($update in $searchResult.Updates) {
            $installer.Updates.Add($update)
        }
        $installer.Install()
    }
}

Limpeza dos Serviços

# Script de limpeza dos serviços
function Cleanup-Services {
    # Remoção dos serviços órfãos
    $orphanedServices = Get-Service | Where-Object {
        $servicePath = (Get-WmiObject Win32_Service -Filter "Name='$($_.Name)'").PathName
        -not (Test-Path $servicePath)
    }
    
    foreach ($service in $orphanedServices) {
        Stop-Service $service.Name
        sc delete $service.Name
    }
}

7. Scripts de Segurança

Verificação de Segurança

# Script de verificação de segurança dos serviços
function Test-ServiceSecurity {
    $issues = @()
    
    # Verificação dos serviços críticos
    $criticalServices = @("RemoteRegistry", "Telnet", "TFTP")
    foreach ($service in $criticalServices) {
        if ((Get-Service $service -ErrorAction SilentlyContinue).Status -eq "Running") {
            $issues += "Service critique $service est en cours d'exécution"
        }
    }
    
    # Verificação das permissões
    $servicePath = "C:\Windows\System32\services.exe"
    $acl = Get-Acl $servicePath
    if (-not ($acl.Access | Where-Object {$_.IdentityReference -eq "NT AUTHORITY\SYSTEM"})) {
        $issues += "Permissions incorrectes sur services.exe"
    }
    
    return $issues
}

Manutenção Automática

# Script de manutenção dos serviços
function Update-ServiceSecurity {
    # Desativação dos serviços não essenciais
    $nonEssentialServices = @(
        "RemoteRegistry",
        "Telnet",
        "TFTP",
        "SNMP"
    )
    
    foreach ($service in $nonEssentialServices) {
        if (Get-Service $service -ErrorAction SilentlyContinue) {
            Stop-Service $service
            Set-Service $service -StartupType Disabled
        }
    }
    
    # Atualização das permissões
    $serviceFolders = @(
        "C:\Windows\System32\drivers",
        "C:\Windows\System32\config"
    )
    
    foreach ($folder in $serviceFolders) {
        $acl = Get-Acl $folder
        $acl.SetAccessRuleProtection($true, $false)
        Set-Acl $folder $acl
    }
}

Conclusão

A proteção dos serviços do Windows exige:

• Um gerenciamento rigoroso dos serviços
• Uma configuração adequada das permissões
• Um monitoramento constante
• Atualizações regulares
• Uma documentação precisa

Pontos-chave a lembrar:

• Desativar os serviços não essenciais
• Manter permissões mínimas
• Monitorar as anomalias
• Realizar auditorias regulares
• Seguir as boas práticas de segurança