Seguridad de los Servicios de Windows: Guía Completa

La securización de los servicios de Windows es un aspecto crucial de la ciberseguridad. Esta guía explora las técnicas avanzadas de protección y gestión de servicios.

1. Gestión de Servicios

Configuración Básica

# Desactivación de los servicios no esenciales
sc config RemoteRegistry start= disabled
sc config Telnet start= disabled
sc config TFTP start= disabled

# Configuración de los permisos
sc sdset RemoteRegistry D:(A;;CCLCSWRPWPDTLOCRRC;;;SY)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;BA)(A;;CCLCSWLOCRRC;;;IU)(A;;CCLCSWLOCRRC;;;SU)

Servicios Críticos

# Identificación de los servicios críticos
$criticalServices = @(
    "RemoteRegistry",
    "Telnet",
    "TFTP",
    "SNMP",
    "IISADMIN",
    "W3SVC"
)

# Desactivación segura
foreach ($service in $criticalServices) {
    if (Get-Service $service -ErrorAction SilentlyContinue) {
        Stop-Service $service
        Set-Service $service -StartupType Disabled
    }
}

2. Securización de los Permisos

Configuración de las ACL

# Configuración de los permisos de los servicios
$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

# Protección de las carpetas de servicios
$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
}

Gestión de Derechos

# Configuración de los derechos de servicio
$serviceRights = @{
    "SeServiceLogonRight" = "SERVICE_LOGON"
    "SeAssignPrimaryTokenPrivilege" = "ASSIGN_PRIMARY_TOKEN"
    "SeIncreaseQuotaPrivilege" = "INCREASE_QUOTA"
}

# Aplicación de los derechos
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. Monitorización de los Servicios

Vigilancia Activa

# Script de monitorización de los servicios
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"
        }
    }
}

Detección de Anomalías

# Script de detección de anomalías
function Detect-ServiceAnomalies {
    $baseline = @{
        "svchost.exe" = @(100, 200)  # Rango de PID 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. Protección contra Ataques

Detección de Servicios Maliciosos

# Script de detección de servicios 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)"
            }
        }
    }
}

Protección contra la Inyección

# Configuración de la protección contra la inyección
$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. Auditoría y Logging

Configuración de la Auditoría

# Activación de la auditoría de los servicios
auditpol /set /category:"System" /success:enable /failure:enable
auditpol /set /category:"Security" /success:enable /failure:enable

# Configuración de los logs
wevtutil sl System /maxsize:4294967296 /retention:true
wevtutil sl Security /maxsize:4294967296 /retention:true

Análisis de los Logs

# Script de análisis de los logs de servicios
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. Mantenimiento y Actualizaciones

Gestión de las Actualizaciones

# Script de actualización de los servicios
function Update-Services {
    # Comprobación de las actualizaciones de 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()
    }
}

Limpieza de Servicios

# Script de limpieza de servicios
function Cleanup-Services {
    # Eliminación de los servicios huérfanos
    $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 Seguridad

Verificación de Seguridad

# Script de verificación de la seguridad de los servicios
function Test-ServiceSecurity {
    $issues = @()
    
    # Comprobación de los servicios 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"
        }
    }
    
    # Comprobación de los permisos
    $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
}

Mantenimiento Automático

# Script de mantenimiento de los servicios
function Update-ServiceSecurity {
    # Desactivación de los servicios no esenciales
    $nonEssentialServices = @(
        "RemoteRegistry",
        "Telnet",
        "TFTP",
        "SNMP"
    )
    
    foreach ($service in $nonEssentialServices) {
        if (Get-Service $service -ErrorAction SilentlyContinue) {
            Stop-Service $service
            Set-Service $service -StartupType Disabled
        }
    }
    
    # Actualización de los permisos
    $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
    }
}

Conclusión

La securización de los servicios de Windows requiere:

• Una gestión estricta de los servicios
• Una configuración adecuada de los permisos
• Una monitorización constante
• Actualizaciones periódicas
• Una documentación precisa

Puntos clave que recordar:

• Desactivar los servicios no esenciales
• Mantener permisos mínimos
• Vigilar las anomalías
• Realizar auditorías periódicas
• Seguir las buenas prácticas de seguridad