Durante la instalación mediante `apt`, se solicitarán varios ajustes. Las opciones predeterminadas generalmente pueden aceptarse. El único ajuste que requiere atención es la dirección de subred utilizada por la red libvirt de mofos (predeterminada: `192.168.90.0/24`).

O

Instale las siguientes dependencias:
- 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

### Consideraciones de seguridad

El uso de sesiones de sistema QEMU/KVM mejora el aislamiento entre las máquinas virtuales anfitrionas e invitadas al ejecutar las instancias de qemu bajo un usuario dedicado (`libvirt-qemu`) y aplicar perfiles de seguridad específicos a cada instancia.

Sin embargo, de forma predeterminada, los usuarios normales no pueden interactuar con el socket del sistema `libvirtd` para gestionar máquinas, redes y otros recursos. Para obtener acceso, los usuarios deben ser miembros del grupo Unix de libvirt o usar sudo. Históricamente, las vulnerabilidades locales de escalada de privilegios han explotado la pertenencia al grupo libvirt para obtener privilegios de root.

Para mitigar estos riesgos, este repositorio proporciona un perfil AppArmor reforzado para el proceso `libvirtd` en sistemas que usan AppArmor. Este perfil restringe significativamente dónde puede escribir archivos `libvirtd` y qué programas puede ejecutar.

Además, se incluyen reglas de `polkit` para controlar aún más las acciones permitidas a los miembros del grupo `libvirt`.

Tenga en cuenta que los perfiles AppArmor se incluyen en el paquete `deb`, pero no se instalan mediante el objetivo `install_files` del Makefile, por lo que deben instalarse por separado.

## Configuración de Mofos

Mofos requiere un archivo de configuración ubicado en `$HOME/.config/mofos/config.toml` con ajustes mínimos para funcionar correctamente. En `/usr/share/mofos/config.minimal.toml` se puede encontrar un ejemplo de configuración mínima, mientras que en `/usr/share/mofos/config.sample.toml` se documenta una configuración más completa.

El siguiente error indica que no se encontró el archivo de configuración:```
[-] Copy the sample configuration file from /usr/share/mofos/config.minimal.toml to ~/.config/mofos/config.toml

Los ajustes de configuración principales que se deben personalizar en los archivos de configuración son los siguientes:
- key (ruta): El archivo de clave privada SSH utilizado para acceder a las máquinas virtuales. Se recomienda crear una clave dedicada para este propósito.
- user (cadena): El nombre de usuario para el acceso SSH a las máquinas virtuales.
- root_password (valor hash): La contraseña hash de root que se establecerá durante la instalación de una nueva plantilla.
- root_ssh_pubkey (cadena): La clave pública SSH que se instalará en el directorio del usuario root durante la instalación de la plantilla.

Además, los siguientes parámetros deben configurarse para la instalación de plantillas:
- ntp
- dns (opcional si se proporciona un proxy)
- proxy

## Instalar una plantilla

### Configurar el cortafuegos

Dado que el proceso de instalación depende del arranque por red PXE, se requiere una conexión a Internet activa. Se deben configurar las siguientes reglas de cortafuegos:```
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

Cuando el parámetro `ip_forward` está establecido en 1, la cadena FORWARD debe configurarse para evitar que otros dispositivos de la red utilicen el host como enrutador.

En general, se recomiendan las siguientes reglas:```
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
}

Se recomienda restringir las reglas de enmascaramiento y reenvío según tus necesidades específicas, para evitar que las máquinas virtuales de Mofos accedan a toda la red del host.

El aislamiento entre máquinas virtuales se aplica automáticamente mediante un hook de libvirt, que requiere nft para funcionar correctamente.


### Instalación

El primer paso es construir la capa inicial: la plantilla. Por defecto, Mofos puede instalar una plantilla basada en Debian 12.```
mofos template create debian-template

La variante se establece en `debian11` porque en Debian 12, la variante `osinfo` para Debian 12 aún no se puede instalar mediante libvirt.

Para instalar otra distribución, modifique el diccionario ubicado en `/usr/lib/python3/dist-packages/mofos/settings.py`.

Cuando se ejecuta el comando anterior, Mofos descarga los archivos netboot y almacena en caché el archivo `tar.gz` en `$HOME/.cache/template-installer`. Actualmente, si el archivo netboot ya existe, Mofos no lo descargará de nuevo. Esto puede causar errores si la caché está desactualizada. Si ocurren tales errores durante la instalación, eliminar la caché forzará a Mofos a descargar una versión actualizada, lo que debería resolver el problema.

A continuación, el archivo se extrae en `/tmp`, y libvirt se configura para servir su contenido mediante TFTP.

Luego se crea la máquina virtual de plantilla y se configura para arrancar mediante PXE, instalando la distribución especificada usando el archivo preseed proporcionado (por defecto `/usr/share/mofos/templates/debian/preseed.cfg.j2`). Este archivo es una plantilla `jinja2`; antes de copiarlo al directorio raíz de TFTP, se inyectan las variables de los archivos de configuración (`ntp`, `proxy`, `dns`, `root_password`).

Al final de la instalación, el script `postinstall` se coloca en el directorio TFTP y se ejecuta en la plantilla. Por defecto, se utiliza el script ubicado en `/usr/share/mofos/templates/postinstall.sh.j2`. Esta plantilla `jinja2` inyecta la clave pública SSH que se configurará en la plantilla.

Además de configurar la clave pública SSH de root, se realizan las siguientes operaciones:
- Deshabilitar el servicio SSH estándar y habilitar un SSHD sobre sockets virtuales (vsock).
- Vaciar el archivo `/etc/resolv.conf`.
- Configurar el tiempo de espera de GRUB a 0 segundos.
- Instalar un hook de initramfs que monta el overlayfs cuando se detecta una partición etiquetada como `overlay`.

Una vez completada la instalación, la máquina virtual de libvirt se recupera y se comprime en un archivo local `qcow2` guardado en el directorio actual.```
$ 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

Este archivo se utiliza automáticamente durante el proceso de importación.

### Importación

El siguiente paso es importar el archivo de plantilla `qcow2` creado en Mofos.```
$ 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

A partir de este punto, la plantilla se puede iniciar y acceder a ella para modificarla según sea necesario.```
$ mofos start debian-template
$ mofos ls
+----+-----------------+---------+-------------+-------+-----+----------------+
| Id | Name            | State   | Description | Alias | Cid | IPv4 address   |
+----+-----------------+---------+-------------+-------+-----+----------------+
| 3  | debian-template | running |             |       | 3   | 192.168.90.202 |
+----+-----------------+---------+-------------+-------+-----+----------------+

## Crear el disco vacío de la capa superior

El siguiente comando crea una capa superior vacía con la etiqueta especificada en la única partición del disco:```
$ mofos template create-overlay-disk

Ten en cuenta que las conexiones SSH se realizan a través de sockets virtuales, por lo que no puedes conectarte por SSH directamente a la máquina recién creada. En su lugar, debes usar el comando mofos ssh. Alternativamente, puedes crear una configuración SSH que especifique un `ProxyCommand `para acceder al puerto SSH de la máquina:```
$ 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

Durante una sesión de `mofos ssh`, se establece previamente un socket `ControlMaster` para acelerar las conexiones posteriores. Por eso no se muestra el MOTD.

## Personalización

Para simplificar la personalización de plantillas y máquinas virtuales, Mofos introduce el concepto de hooks y tags. Para cada tag, se puede ejecutar un hook correspondiente (un script de Bash) para realizar acciones automatizadas en la máquina virtual o plantilla objetivo y configurarla en consecuencia.

Los hooks mínimos se encuentran en `/usr/share/mofos/hooks`. Son scripts de Bash sencillos que reciben las siguientes entradas:```
TAG=$1
NAME=$2
OS=$3
DISTRIB=$4
HOSTNAME=$5

Este script crea dinámicamente un inventario y ejecuta un playbook contra él.

### Máquina virtual: nuevo hook

Durante la creación de máquinas virtuales, se puede utilizar otro hook, por ejemplo, para aleatorizar el nombre de host.

Por defecto, Mofos genera un alias basado en la convención clásica de nombres de Windows (p. ej., `DESKTOP-2BF9753`). Este nombre, junto con otra información, se pasa al script del hook:```
#!/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}"

Luego, durante la creación de la máquina virtual, se ejecutará este script:```
$ 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

Al igual que en la fase de instalación, los playbooks de Ansible también se pueden ejecutar en esta etapa. En este caso, se puede usar el comando `mofos inventory` para generar un inventario de Ansible, lo que simplifica el proceso de seleccionar y acceder a las máquinas virtuales:```
$ 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"
    ]

### Máquina virtual - hook de inicio

De manera similar, el hook de inicio se ejecuta cuando una máquina virtual arranca. Normalmente se utiliza para lanzar servicios que la máquina virtual necesita.

Por ejemplo, para habilitar una integración perfecta con Windows dentro de la máquina virtual, puedes instalar `Xpra`.

Primero instala `ansible`:```
# apt install ansible

Admitimos una amplia gama de opciones para `list-unused` para **enumerar todos los permisos excedentes**, como:

- **La acción excedente es solo "read"** : `--excess-actions read`
- **Si solo quieres ver si hay acciones "write" sin usar**: `--excess-actions write`
- **Ver todos los permisos excedentes (potencialmente peligrosos)**: No necesitarás esto porque es el predeterminado
- **Para escanear permisos excedentes de un tipo de recurso específico**: Por ejemplo `--include-types sqs` o `--include-types s3,sqs,sns,ec2`
- **Para excluir un tipo de recurso del escaneo**: `--exclude-types rds`
- **Para escanear un rol específico**: `--include-roles MyRoleName`
- **Modificar el número de días para que un permiso se considere no utilizado**: Por defecto, la herramienta obtendrá los datos máximos disponibles (actualmente 90 días), y todos los permisos que no se usaron hasta el último día disponible se reportarán como no utilizados.
- **Pero, ¿qué pasa si el usuario verificó el último inicio de sesión en los últimos 30 días?**```
$ 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   

A continuación, ejecuta el playbook `Xpra`. Este playbook instala paquetes desde los mirrors de Debian. Ten en cuenta que la red Mofos no configura DNS, proxy ni una puerta de enlace predeterminada por defecto. Estos deben configurarse antes de ejecutar el playbook.

No se requieren modificaciones al playbook por defecto.```
ansible-playbook playbooks/xpra.yml -l test2

De lo contrario, el servicio se iniciará automáticamente en el próximo reinicio.

Luego, el servicio del cliente local también se puede iniciar manualmente:```
$ mofos xpra start test2

Para asegurar que este mecanismo funcione sin problemas y automáticamente, el comando `mofos xpra` puede iniciarse desde el hook de inicio.```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}"

### Portapapeles

Mofos también puede gestionar el portapapeles entre las máquinas virtuales y el host. La idea es configurar una combinación de teclas específica para activar una conexión SSH a la VM enfocada actualmente, ya sea para extraer el portapapeles X11 o para enviar contenido a él.

Para enviar contenido al portapapeles X11 de la máquina virtual:```
mofos clipboard in pentest-0

Para cada operación, mofos establecerá una conexión SSH a la máquina virtual y usará `xclip` y en el host `wl-copy` o `xclip` según la tecnología de ventanas (wayland vs X11).

El nombre de la máquina en el trace anterior puede omitirse; en ese caso, el script identificará la máquina virtual enfocada actualmente y la tomará como objetivo.

Si estás usando Gnome wayland, es posible que necesites instalar la extensión de shell de Gnome `[email protected]` con `sudo make install_gnome_extension`.
Tendrás que cerrar la sesión y volver a iniciarla para asegurarte de que la extensión queda instalada.

### Configurar el enrutamiento entre máquinas

En mofos existen dos opciones para enrutar una VM:
- `mofos route`, que toma una puerta de enlace y configura una `ip rule` en el host para enrutar la máquina virtual a través de esa puerta de enlace.
- `mofos pivot`, que toma otra máquina mofos, recupera su dirección IP y la configura como puerta de enlace predeterminada para la máquina virtual actual.

Ambas opciones pueden aceptar un servidor DNS para configurarlo.

### Configurar túneles a través de cajas de pentest

El comando `mofos tunnel` configura una VPN SSH (`ssh -w`) para enrutar el tráfico de una máquina mofos a través de un servidor. Esta funcionalidad depende de unas pocas configuraciones:

Concretamente, el comando `mofos tunnel` realiza las siguientes acciones (aquí no hay magia negra):
1. Crea una interfaz tun local (`sudo /usr/libexec/mofos/mofosnet.py tun add pentest_box`) y asigna una dirección IP a esta interfaz.
2. Ejecuta el `tunneling.command` en el servidor remoto; este comando debería crear una interfaz tun para luego enlazarla con la local (`/usr/libexec/mofos/mofosnet.py sshvpn start pentest_box`).
3. Enruta el tráfico de una máquina mofos a través de la puerta de enlace de la caja remota (`/usr/libexec/mofos/mofosnet.py route mofos_vm_ip gateway_ip`); la puerta de enlace predeterminada de la máquina virtual mofos también se cambia.

El `tunneling.command` debe definirse en el archivo de configuración `/etc/mofos/mofosnet.toml`. Por ejemplo:```toml
[tunneling.command]
start = "sudo ssh-vpn start"  # the peer remote address will be supplied as argv[1]
stop = "sudo ssh-vpn stop"

La opción `force` desconecta y vuelve a conectar un dispositivo. Se usa normalmente para
volver a conectar un dispositivo que se ha desenchufado sin haber sido desconectado antes.

Nota: conectar un dispositivo USB solo es válido durante la vida actual de la máquina virtual. Cuando esta se detiene, el dispositivo se desconecta automáticamente.

### Gestión de dispositivos PCI

Al igual que con los dispositivos USB, mofos permite conectar un dispositivo PCI a una máquina virtual en ejecución; los comandos son los mismos. 

Una limitación adicional afecta a algunos dispositivos PCI que pertenecen a un grupo. Por ejemplo, conectar la tarjeta Ethernet a una máquina virtual en ejecución puede requerir mover todo el grupo PCI dentro de la máquina virtual. Como no se puede hacer de forma secuencial, aún no está soportado. Sin embargo, para un dispositivo PCI único, como una tarjeta de red Wi-Fi, funciona correctamente.

### Carpetas compartidas

El comando `mofos mount` crea carpetas compartidas y puede montar el sistema de archivos recién agregado en un directorio dentro de la máquina virtual. `mofos umount` desmontará el directorio y eliminará las carpetas compartidas de la configuración de la máquina virtual.

Este mecanismo se basa en la tecnología `virtiofsd`, que requiere habilitar la memoria compartida; esto ahora se hace por defecto al crear una máquina virtual. De lo contrario, el siguiente comando la habilitará:```console
virt-xml -c qemu:///system --edit --memorybacking source.type=memfd,access.mode=shared DOMAIN

La variable `SHARE_DIRS` se reutiliza en la política, sin embargo, debido a las limitaciones de apparmor, no es posible reutilizarla para las directivas `pivot_root`. Por lo tanto, es necesario adaptar manualmente las directivas `pivot_root` para cada uno de los directorios compartidos.

Para montar un directorio local:```
mofos mount test ./Public/share -d /home/user/share

- OpenSSH debería configurarse con un shell `PowerShell` en lugar de `cmd.exe`.```powershell
New-ItemProperty -Path "HKLM:\SOFTWARE\OpenSSH" `
                 -Name DefaultShell `
                 -Value "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe" `
                 -PropertyType String `
                 -Force

## Autocompletado

El autocompletado debería funcionar de fábrica para `bash` y `fish`. Para `zsh`, puede ser necesario ejecutar los siguientes comandos:```
autoload -Uz compinit
compinit
source /usr/share/zsh/vendor-completions/_mofos

Con interfaces de red heredadas `/etc/network/interfaces`:```
iface eth0 inet dhcp
  client no