Während der `apt`-Installation werden verschiedene Einstellungen abgefragt. Die Standardoptionen können im Allgemeinen akzeptiert werden. Die einzige Einstellung, die Beachtung erfordert, ist die Subnetz-Adresse, die vom mofos-libvirt-Netzwerk verwendet wird (Standard: `192.168.90.0/24`).

ODER 

Installieren Sie die folgenden Abhängigkeiten:
- guestfs-tools
- libnotify-bin
- libvirt
- libvirt-clients
- libvirt-daemon
- make
- python3-click
- python3-click-completion
- python3-colorama
- python3-cryptography
- python3-dbus
- python3-jinja2
- python3-lxml
- python3-prettytable
- python3-pyroute2
- python3-tqdm
- qemu-system-common 
- qemu-system-modules-spice
- socat
- spice-client-gtk
- sudo
- virtinst
- virt-install
- virtiofsd
- virt-manager
- virt-viewer```
make install_files

### Sicherheitsaspekte

Die Verwendung von QEMU/KVM-Systemsitzungen verbessert die Isolation zwischen Host- und Gast-VMs, indem qemu-Instanzen unter einem dedizierten Benutzer (`libvirt-qemu`) ausgeführt werden und für jede Instanz spezifische Sicherheitsprofile angewendet werden.

Standardmäßig können normale Benutzer jedoch nicht über den System-Socket von `libvirtd` auf die Verwaltung von Maschinen, Netzwerken und anderen Ressourcen zugreifen. Um Zugriff zu erhalten, müssen Benutzer entweder Mitglied der libvirt-Unix-Gruppe sein oder sudo verwenden. In der Vergangenheit wurden lokale Privilege-Escalation-Schwachstellen ausgenutzt, um über die Mitgliedschaft in der libvirt-Gruppe Root-Rechte zu erlangen.

Um diese Risiken zu mindern, stellt dieses Repository ein verstärktes AppArmor-Profil für den `libvirtd`-Prozess auf Systemen mit AppArmor bereit. Dieses Profil schränkt erheblich ein, wohin `libvirtd` Dateien schreiben kann und welche Programme es ausführen darf.

Darüber hinaus sind `polkit`-Regeln enthalten, um die für Mitglieder der `libvirt`-Gruppe zulässigen Aktionen weiter zu kontrollieren.

Beachten Sie, dass die AppArmor-Profile im `deb`-Paket enthalten sind, aber nicht vom `install_files`-Ziel des Makefiles installiert werden und daher separat installiert werden müssen.

## Mofos-Konfiguration

Mofos benötigt eine Konfigurationsdatei unter `$HOME/.config/mofos/config.toml` mit minimalen Einstellungen, um korrekt zu funktionieren. Eine minimale Beispielkonfiguration finden Sie unter `/usr/share/mofos/config.minimal.toml`, während eine umfassendere Konfiguration unter `/usr/share/mofos/config.sample.toml` dokumentiert ist.

Der folgende Fehler zeigt an, dass die Konfigurationsdatei nicht gefunden wurde:```
[-] Copy the sample configuration file from /usr/share/mofos/config.minimal.toml to ~/.config/mofos/config.toml

Die wichtigsten Konfigurationseinstellungen, die in den Konfigurationsdateien angepasst werden müssen, sind wie folgt:
- key (Pfad): Die SSH-Private-Key-Datei, die für den Zugriff auf die virtuellen Maschinen verwendet wird. Es wird empfohlen, dafür einen eigenen Schlüssel zu erstellen.
- user (String): Der Benutzername für den SSH-Zugriff auf die virtuellen Maschinen.
- root_password (gehashter Wert): Das gehashte Root-Passwort, das während der Installation einer neuen Vorlage festgelegt werden soll.
- root_ssh_pubkey (String): Der öffentliche SSH-Schlüssel, der während der Vorlageninstallation im Verzeichnis des Root-Benutzers installiert werden soll.

Darüber hinaus müssen die folgenden Parameter für die Vorlageninstallation konfiguriert werden:
- ntp
- dns (optional, wenn ein Proxy bereitgestellt wird)
- proxy

## Vorlage installieren

### Firewall konfigurieren

Da der Installationsprozess auf PXE-Netboot basiert, ist eine aktive Internetverbindung erforderlich. Die folgenden Firewall-Regeln sollten konfiguriert werden:```
sysctl net.ipv4.ip_forward=1
iptables -t nat -I POSTROUTING -s 192.168.90.0/24 -j MASQUERADE
iptables -t nat -I POSTROUTING -s 192.168.91.0/24 -j MASQUERADE

Wenn der Parameter `ip_forward` auf 1 gesetzt ist, sollte die FORWARD-Kette so konfiguriert werden, dass andere Geräte im Netzwerk den Host nicht als Router verwenden können.

Insgesamt werden die folgenden Regeln empfohlen:```
iptables -I INPUT -i mof0 -p udp --sport 68 --dport 67 -j ACCEPT -m comment --comment "mofos dhcp"
iptables -I INPUT -i mof0 -p udp --dport 69 -j ACCEPT -m comment --comment "mofos tftp"
iptables -I OUTPUT -o mof0 -j ACCEPT -m comment --comment "host -> mofos"
iptables -I FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
iptables -I FORWARD -i mof0 -j ACCEPT -m comment --comment "mofos ->"
iptables -t nat -I POSTROUTING -s 192.168.90.0/24 -j MASQUERADE
iptables -t nat -I POSTROUTING -s 192.168.91.0/24 -j MASQUERADE

chain input {
  type filter hook input priority 0; policy drop
  
  iifname "install-*" ip daddr 255.255.255.255 udp sport 68 udp dport 67 accept comment "mofos dhcp"
  iifname "mof0" ip daddr 255.255.255.255 udp sport 68 udp dport 67 accept comment "mofos dhcp"
  iifname "install-*" udp dport 69 accept comment "mofos tftp"
}

chain forward {
  type filter hook forward priority 0; policy drop
  
  ct state established,related accept;
  ct state invalid drop;
  
  iifname "mof0" counter accept
  iifname "install-*" counter accept
}

chain output {
  type filter hook output priority 0; policy drop
  
  oifname "mof0" counter accept
}

Es wird empfohlen, Masquerade- und Weiterleitungsregeln basierend auf Ihren spezifischen Anforderungen einzuschränken, um zu verhindern, dass virtuelle Maschinen von mofos auf das gesamte Host-Netzwerk zugreifen.

Die Isolation zwischen virtuellen Maschinen wird automatisch durch einen libvirt-Hook erzwungen, der nft benötigt, um ordnungsgemäß zu funktionieren.

### Installation

Der erste Schritt besteht darin, die Basisschicht zu erstellen: die Vorlage. Standardmäßig kann Mofos eine auf Debian 12 basierende Vorlage installieren.```
mofos template create debian-template

Die Variante ist auf `debian11` gesetzt, da in Debian 12 die `osinfo`-Variante für Debian 12 noch nicht über libvirt installierbar ist.

Um eine andere Distribution zu installieren, ändern Sie das Dictionary unter `/usr/lib/python3/dist-packages/mofos/settings.py`.

Wenn der obige Befehl ausgeführt wird, lädt Mofos die Netboot-Dateien herunter und speichert das `tar.gz`-Archiv im Cache unter `$HOME/.cache/template-installer`. Derzeit wird das Netboot-Archiv nicht erneut heruntergeladen, wenn es bereits vorhanden ist. Dies kann zu Fehlern führen, wenn das zwischengespeicherte Archiv veraltet ist. Wenn solche Fehler während der Installation auftreten, erzwingt das Entfernen des zwischengespeicherten Archivs, dass Mofos eine aktualisierte Version herunterlädt, was das Problem beheben sollte.

Anschließend wird das Archiv nach `/tmp` extrahiert und libvirt wird so konfiguriert, dass es seine Inhalte über TFTP bereitstellt.

Die virtuelle Vorlagenmaschine wird dann erstellt und so eingerichtet, dass sie über PXE bootet und die angegebene Distribution mithilfe der bereitgestellten Preseed-Datei installiert (standardmäßig `/usr/share/mofos/templates/debian/preseed.cfg.j2`). Diese Datei ist eine `jinja2`-Vorlage; bevor sie in das TFTP-Root-Verzeichnis kopiert wird, werden Variablen aus den Konfigurationsdateien (`ntp`, `proxy`, `dns`, `root_password`) eingefügt.

Am Ende der Installation wird das `postinstall`-Skript im TFTP-Verzeichnis abgelegt und auf der Vorlage ausgeführt. Standardmäßig wird das Skript unter `/usr/share/mofos/templates/postinstall.sh.j2` verwendet. Diese `jinja2`-Vorlage fügt den öffentlichen SSH-Schlüssel ein, der auf der Vorlage konfiguriert werden soll.

Zusätzlich zur Konfiguration des öffentlichen SSH-Root-Schlüssels werden die folgenden Vorgänge durchgeführt:
- Den standardmäßigen SSH-Dienst deaktivieren und einen SSHD über virtuelle Sockets (vsock) aktivieren.
- Die Datei `/etc/resolv.conf` leeren.
- Den GRUB-Timeout auf 0 Sekunden konfigurieren.
- Einen initramfs-Hook installieren, der das overlayfs einhängt, wenn eine Partition mit der Bezeichnung `overlay` erkannt wird.

Sobald die Installation abgeschlossen ist, wird die libvirt-Virtualmaschine übernommen und in eine lokale `qcow2`-Datei komprimiert, die im aktuellen Verzeichnis gespeichert wird.```
$ mofos template create debian-template
[*] Installing debian-template
[*] Configure the SSH host key of the template
[*] Waiting for the installation to be complete
[*] Installation is complete
[*] Downloading the resulting qcow2 disk
[*] Compressing the disk
[*] Save template's public ssh host key
[+] Template installation finished
[+] Template disk is debian-template-disk.qcow2

Diese Datei wird während des Importvorgangs automatisch verwendet.

### Import

Der nächste Schritt besteht darin, die erstellte `qcow2`-Vorlagendatei in Mofos zu importieren.```
$ mofos template import debian-template debian-template-disk.qcow2 http://debian.org/debian/11 
[*] Uploading debian-template-disk.qcow2 to mofos pool
[*] Creating the virtual machine debian-template
[*] Configuring the template metadata
[*] Configuring the SSH key
[+] debian-template successfully imported

Ab diesem Punkt kann die Vorlage gestartet und bei Bedarf zur Änderung aufgerufen werden.```
$ mofos start debian-template
$ mofos ls
+----+-----------------+---------+-------------+-------+-----+----------------+
| Id | Name            | State   | Description | Alias | Cid | IPv4 address   |
+----+-----------------+---------+-------------+-------+-----+----------------+
| 3  | debian-template | running |             |       | 3   | 192.168.90.202 |
+----+-----------------+---------+-------------+-------+-----+----------------+

## Leere Disk für die obere Ebene erstellen

Der folgende Befehl erstellt eine leere obere Ebene mit dem angegebenen Label auf der einzigen Partition der Disk:```
$ mofos template create-overlay-disk

Beachten Sie, dass SSH-Verbindungen über virtuelle Sockets hergestellt werden, sodass Sie sich nicht direkt per SSH mit der neu erstellten Maschine verbinden können. Stattdessen müssen Sie den Befehl mofos ssh verwenden. Alternativ können Sie eine SSH-Konfiguration erstellen, die einen `ProxyCommand `angibt, um auf den SSH-Port der Maschine zuzugreifen:```
$ mofos inventory --format ssh
Host debian-template
	User user
	PasswordAuthentication no
	IdentityFile /home/user/.ssh/id_ed25519
	ProxyCommand /usr/bin/mofos proxy-cmd %h
	CanonicalizeHostname=no

Host test
	User user
	PasswordAuthentication no
	IdentityFile /home/user/.ssh/id_ed25519
	ProxyCommand /usr/bin/mofos proxy-cmd %h
	CanonicalizeHostname=no

Während einer `mofos ssh`-Sitzung wird im Voraus ein `ControlMaster`-Socket eingerichtet, um nachfolgende Verbindungen zu beschleunigen. Aus diesem Grund wird die MOTD nicht angezeigt.

## Anpassung

Um die Anpassung von Vorlagen und virtuellen Maschinen zu vereinfachen, führt Mofos das Konzept von Hooks und Tags ein. Für jedes Tag kann ein entsprechender Hook (ein Bash-Skript) ausgeführt werden, um automatisierte Aktionen auf der Ziel-VM oder Vorlage durchzuführen und sie entsprechend zu konfigurieren.

Minimale Hooks befinden sich in `/usr/share/mofos/hooks`. Dabei handelt es sich um einfache Bash-Skripte, die die folgenden Eingaben erhalten:```
TAG=$1
NAME=$2
OS=$3
DISTRIB=$4
HOSTNAME=$5

Dieses Skript erstellt dynamisch ein Inventar und führt ein Playbook dagegen aus.

### Virtuelle Maschine - neuer Hook

Während der Erstellung der virtuellen Maschine kann ein weiterer Hook verwendet werden, um beispielsweise den Hostnamen zu randomisieren.

Standardmäßig erzeugt Mofos einen Alias basierend auf der klassischen Windows-Namenskonvention (z. B. `DESKTOP-2BF9753`). Dieser Name wird zusammen mit anderen Informationen an das Hook-Skript übergeben:```
#!/bin/bash

TAG=$1
NAME=$2
OS=$3
DISTRIB=$4
HOSTNAME=$5

if [ -z "${TAG}" ] || [ -z "${NAME}" ] || [ -z "${OS}" ] ; then
  exit 1
fi

if [ -z "${HOSTNAME}" ] ; then
  HOSTNAME="${NAME}"
fi

mofos run -u root "${NAME}" "echo ${HOSTNAME} > /etc/hostname && hostname ${HOSTNAME}"

Dann wird dieses Skript während der Erstellung der virtuellen Maschine ausgeführt:```
$ mofos new test2 --tags test 
[*] New virtual machine name is test2
[+] Virtual machine test2 successfully created
[*] Triggering post install actions
[*] Create SSH known_hosts entries for test2
[*] Waiting for test2 to be up
[*] Running new hook: test
[+] test2 is ready

Ähnlich wie in der Installationsphase können Ansible-Playbooks auch in dieser Phase ausgeführt werden. In diesem Fall kann der Befehl `mofos inventory` verwendet werden, um ein Ansible-Inventar zu erzeugen, was die Auswahl und den Zugriff auf virtuelle Maschinen vereinfacht:```
$ mofos inventory 
{
    "_meta": {
        "hostvars": {
            "debian-template": {
                "ansible_host": "debian-template",
                "ansible_ssh_common_args": "-o ProxyCommand='/usr/bin/mofos proxy-cmd %h'  -o CanonicalizeHostname=no"
            },
            "test": {
                "ansible_host": "test",
                "ansible_ssh_common_args": "-o ProxyCommand='/usr/bin/mofos proxy-cmd %h'  -o CanonicalizeHostname=no"
            },
            "test2": {
                "ansible_host": "test2",
                "ansible_ssh_common_args": "-o ProxyCommand='/usr/bin/mofos proxy-cmd %h'  -o CanonicalizeHostname=no"
            }
        }
    },
    "debian": [
        "debian-template",
        "test",
        "test2"
    ],
    "test": [
        "test2"
    ]

### Virtuelle Maschine – Start-Hook

Ebenso wird der Start-Hook ausgeführt, wenn eine virtuelle Maschine startet. Er wird typischerweise verwendet, um Dienste zu starten, die von der virtuellen Maschine benötigt werden.

Um beispielsweise eine nahtlose Windows-Integration innerhalb der virtuellen Maschine zu ermöglichen, kannst du `Xpra` installieren.

Zuerst `ansible` installieren:```
# apt install ansible

Bitte fügen Sie den zu übersetzenden Markdown-Text ein.```
$ ansible-playbook playbooks/user.yml -l test2
Using /home/user/mofos/ansible/ansible.cfg as config file
[WARNING]: Found both group and host with same name: test

PLAY [Create and configure a user]

[...]

PLAY RECAP
test2 : ok=4 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0   

Führen Sie als Nächstes das `Xpra`-Playbook aus. Dieses Playbook installiert Pakete von Debian-Mirrors. Bitte beachten Sie, dass das Mofos-Netzwerk standardmäßig kein DNS, keinen Proxy und kein Standard-Gateway konfiguriert. Diese müssen eingerichtet werden, bevor das Playbook ausgeführt wird.

Standardmäßig sind keine Änderungen am Playbook erforderlich.```
ansible-playbook playbooks/xpra.yml -l test2

Andernfalls startet der Dienst beim nächsten Neustart automatisch.

Dann kann der lokale Client-Dienst auch manuell gestartet werden:```
$ mofos xpra start test2

Um sicherzustellen, dass dieser Mechanismus reibungslos und automatisch abläuft, kann der Befehl `mofos xpra` aus dem Start-Hook gestartet werden.```bash
#!/bin/bash

TAG=$1
NAME=$2
OS=$3
DISTRIB=$4
HOSTNAME=$5

if [ -z "${TAG}" ] || [ -z "${NAME}" ] ; then
exit 1
fi

mofos xpra start "${NAME}"

### Zwischenablage

Mofos kann auch die Zwischenablage zwischen virtuellen Maschinen und dem Host verwalten. Die Idee ist, eine bestimmte Tastenkombination zu konfigurieren, die eine SSH-Verbindung zur aktuell fokussierten VM auslöst, entweder um die X11-Zwischenablage abzurufen oder um Inhalte dorthin zu übertragen.

Um Inhalte in die X11-Zwischenablage der virtuellen Maschine zu übertragen:```
mofos clipboard in pentest-0

Für jeden Vorgang stellt mofos eine SSH-Verbindung zur virtuellen Maschine her und verwendet xclip sowie auf dem Host `wl-copy` oder `xclip` – je nach Fenstertechnologie (wayland vs. X11).

Der Maschinenname im obigen Trace kann weggelassen werden; in diesem Fall ermittelt das Skript die aktuell fokussierte virtuelle Maschine und zielt auf diese.

Wenn Sie Gnome wayland verwenden, müssen Sie möglicherweise die Gnome-Shell-Erweiterung [email protected] mit `sudo make install_gnome_extension` installieren.
Sie müssen sich ab- und wieder anmelden, um sicherzustellen, dass die Erweiterung installiert ist.

### Einrichten des Routings zwischen Maschinen

Es gibt zwei Optionen in mofos, um eine VM zu routen:
- `mofos route`, das ein Gateway annimmt und auf dem Host eine `ip rule` konfiguriert, um die virtuelle Maschine über dieses Gateway zu routen.
- `mofos pivot`, das eine andere mofos-Maschine nimmt, deren IP-Adresse abruft und sie als Standard-Gateway für die aktuelle virtuelle Maschine konfiguriert.

Beide Optionen können einen DNS-Server annehmen, um ihn zu konfigurieren.

### Einrichten von Tunneling durch Pentest-Boxen

Der Befehl `mofos tunnel` richtet ein SSH-VPN (`ssh -w`) ein, um den Datenverkehr einer mofos-Maschine über einen Server zu routen. Diese Funktion hängt von einigen Konfigurationen ab:

Konkret führt der Befehl `mofos tunnel` die folgenden Aktionen aus (keine schwarze Magie):
1. Erstellen einer lokalen tun-Schnittstelle (`sudo /usr/libexec/mofos/mofosnet.py tun add pentest_box`) und Zuweisen einer IP-Adresse zu dieser Schnittstelle.
2. Ausführen von `tunneling.command` auf dem Remote-Server; dieser Befehl sollte eine tun-Schnittstelle erstellen, die dann mit der lokalen verbunden wird (`/usr/libexec/mofos/mofosnet.py sshvpn start pentest_box`).
3. Routen des Datenverkehrs einer mofos-Maschine über das Gateway der Remote-Box (`/usr/libexec/mofos/mofosnet.py route mofos_vm_ip gateway_ip`); das Standard-Gateway der mofos-VM wird ebenfalls geändert.

Der Befehl `tunneling.command` muss in der Konfigurationsdatei `/etc/mofos/mofosnet.toml` definiert werden. Zum Beispiel:```toml
[tunneling.command]
start = "sudo ssh-vpn start"  # the peer remote address will be supplied as argv[1]
stop = "sudo ssh-vpn stop"

Die Option `force` löst ein Gerät ab und hängt es wieder an. Sie wird üblicherweise verwendet, um ein Gerät erneut anzuhängen, das entfernt wurde, ohne zuvor abgelöst worden zu sein.

Hinweis: Das Anhängen eines USB-Geräts gilt nur für die aktuelle Lebensdauer der virtuellen Maschine. Wenn sie beendet wird, wird das Gerät automatisch abgelöst.

### Verwaltung von PCI-Geräten

Ähnlich wie bei USB-Geräten ermöglicht mofos das Anhängen eines PCI-Geräts an eine laufende virtuelle Maschine; die Befehle sind dieselben.

Eine zusätzliche Einschränkung betrifft einige PCI-Geräte, die zu einer Gruppe gehören. Beispielsweise kann das Anhängen der Ethernet-Karte an eine laufende virtuelle Maschine erforderlich machen, die gesamte PCI-Gruppe in die virtuelle Maschine zu verschieben. Da dies nicht sequenziell erfolgen kann, wird es derzeit nicht unterstützt. Bei einem einzelnen PCI-Gerät wie einer WLAN-Netzwerkkarte funktioniert es jedoch einwandfrei.

### Gemeinsame Ordner

Der Befehl `mofos mount` erstellt einen gemeinsamen Ordner und kann das neu hinzugefügte Dateisystem in ein Verzeichnis innerhalb der virtuellen Maschine einhängen. `mofos umount` hängt das Verzeichnis aus und entfernt die gemeinsamen Ordner aus der Konfiguration der virtuellen Maschine.

Dieser Mechanismus basiert auf der `virtiofsd`-Technologie, die die Aktivierung von gemeinsamem Speicher erfordert. Dies geschieht standardmäßig beim Erstellen einer virtuellen Maschine. Andernfalls aktiviert der folgende Befehl dies:```console
virt-xml -c qemu:///system --edit --memorybacking source.type=memfd,access.mode=shared DOMAIN

Die Variable `SHARE_DIRS` wird in der Policy wiederverwendet, jedoch ist es aufgrund von AppArmor-Einschränkungen nicht möglich, sie für `pivot_root`-Direktiven wiederzuverwenden. Daher müssen die `pivot_root`-Direktiven für jedes gemeinsame Verzeichnis manuell angepasst werden.

Um ein lokales Verzeichnis zu mounten:```
mofos mount test ./Public/share -d /home/user/share

- OpenSSH sollte mit einer `PowerShell`-Shell anstelle von `cmd.exe` konfiguriert werden.```powershell
New-ItemProperty -Path "HKLM:\SOFTWARE\OpenSSH" `
                 -Name DefaultShell `
                 -Value "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe" `
                 -PropertyType String `
                 -Force

## Autovervollständigung

Autovervollständigung sollte für `bash` und `fish` standardmäßig funktionieren. Für `zsh` müssen möglicherweise die folgenden Befehle ausgeführt werden:```
autoload -Uz compinit
compinit
source /usr/share/zsh/vendor-completions/_mofos

Mit Legacy-Netzwerkschnittstellen `/etc/network/interfaces`:```
iface eth0 inet dhcp
  client no