Constructor de imágenes de VM de Kali

Este es el script de compilación para crear las imágenes de Kali Linux Máquina Virtual (VM).

Actualmente hay dos métodos de compilación posibles:

• build.sh - compila directamente desde tu máquina
• build-in-container.sh - compila desde un contenedor (Docker o Podman)

En cualquier caso, la compilación se realiza dentro de una máquina virtual que se crea sobre la marcha con la herramienta de compilación debos. Debos usa fakemachine internamente, que a su vez depende de QEMU/KVM.

Requisitos previos

Asegúrate de que el repositorio git esté clonado localmente:

$ sudo apt install -y git
$ git clone https://gitlab.com/kalilinux/build-scripts/kali-vm.git
$ cd kali-vm/

Configuración del usuario

Debido a los requisitos de QEMU/KVM, debes ser parte del grupo kvm. Puedes comprobarlo con:

$ # Not apart of the group
$ grep kvm /etc/group
kvm:x:104:
$
$ # In the group
$ grep kvm /etc/group
kvm:x:104:kali

Si tu nombre de usuario no aparece en la línea devuelta, significa que no estás en el grupo, y debes añadirte al grupo kvm:

$ sudo adduser $USER kvm

Luego cierra la sesión y vuelve a iniciarla para que el cambio surta efecto.

Compilar desde el host

Si compilas directamente desde tu máquina, usando build.sh, necesitarás instalar debos:

$ sudo apt install -y 7zip debos dosfstools qemu-utils zerofree

Luego usa el script build.sh para compilar una imagen de VM directamente en tu máquina.

Compilar desde un contenedor

Si prefieres compilar desde un contenedor, necesitarás instalar y configurar docker o podman en tu máquina. Luego usa el script build-in-container.sh para compilar una imagen.

build-in-container.sh es simplemente un envoltorio sobre build.sh. Detecta qué motor de contenedores compatible con OCI usar, se encarga de crear la imagen de contenedor si no existe, y finalmente inicia el contenedor para realizar la compilación desde su interior.

docker requiere que el usuario sea añadido al grupo de Docker, igual que antes con KVM, o usar la cuenta root (p. ej. $ sudo ./build-in-container.sh). podman ha sido probado tanto en modo rootful (p. ej. $ sudo ./build-in-container.sh) como rootless (p. ej. $ ./build-in-container.sh).

Compilación de una imagen

Usa build.sh o build-in-container.sh, según tu preferencia. De aquí en adelante usaremos build.sh por brevedad.

Ejemplos

El mejor punto de partida, como siempre, es el mensaje de uso:

$ ./build.sh -h
Usage: build.sh <options> [-- <debos options>]

Build a Kali Linux VM image

Build options:
  -a ARCH     Build an image for this architecture, default: amd64
              Supported values: amd64
  -b BRANCH   Kali branch used to build the image, default: kali-rolling
              Supported values: kali-dev kali-last-snapshot kali-rolling
  -f FORMAT   Format to export the image to, default depends on the VARIANT
              Supported values: hyperv ova ovf qemu raw vagrant virtualbox vmware
  -k          Keep raw disk image and other intermediary build artifacts
  -m MIRROR   Mirror used to build the image, default: http://http.kali.org/kali
  -r ROOTFS   rootfs to use to build the image, default: none
  -s SIZE     Size of the disk image in GB, default: 86
  -v VARIANT  Variant of image to build (see below for details), default: generic
              Supported values: generic hyperv qemu rootfs virtualbox vmware
  -x VERSION  What to name the image release as, default: rolling
  -z          Zip images and metadata files after the build

Customization options:
  -D DESKTOP  Desktop environment installed in the image, default: xfce
              Supported values: e17 gnome i3 kde lxde mate xfce none
  -H HOSTNAME Set system host name, default: kali
  -K KEYBOARD Set keyboard layout, default: us
              Refer to the README.md for more details
  -L LOCALE   Set locale, default: en_US.UTF-8
  -P PACKAGES Install extra packages (comma/space separated list)
  -T TOOLSET  The selection of tools to include in the image, default: default
              Supported values: default everything headless large none
  -U USERPASS Username and password, separated by a colon, default: kali:kali
  -Z TIMEZONE Set timezone, default: America/New_York

The different variants of images are:
  generic     Image with all virtualization support pre-installed, default format: raw
  hyperv      Image pre-configured for Hyper-V "Enhanced Session Mode", default format: hyperv
  qemu        Image with QEMU and SPICE guest agents pre-installed, default format: qemu
  rootfs      Not an image, a root filesystem (no bootloader/kernel), packed in a .tar.gz
  virtualbox  Image with VirtualBox guest utilities pre-installed, default format: virtualbox
  vmware      Image with Open VM Tools pre-installed, default format: vmware

The different formats are:
  hyperv      VHDX disk image, powershell install scripts
  ova         streamOptimized VMDK disk image, OVF metadata file, packed in a OVA archive
  ovf         monolithicSparse VMDK disk image, OVF metadata file
  qemu        QCOW2 disk image, no metadata
  raw         sparse disk image, no metadata
  virtualbox  VDI disk image, .vbox metadata file
  vmware      2GbMaxExtentSparse VMDK disk image, VMX metadata file

Supported environment variables:
  http_proxy  HTTP proxy URL, refer to the README.md for more details

Most useful debos options:
  --artifactdir DIR   Set artifact directory, default: images
  --memory, -m  SIZE  Limit amount of memory to build VM in GB, default: 4G
  --scratchsize SIZE  Limit amount of HDD to build VM in GB, default: 45G
  --debug-shell       Get a shell on the VM
  --help, -h          See the complete list of options for debos

Refer to the README.md for examples

Las opciones predeterminadas compilarán una imagen de Kali rolling, con el escritorio predeterminado y el conjunto de herramientas predeterminado para la arquitectura AMD64.

Esta es una imagen de disco raw, es decir, una imagen binaria simple del disco (que se puede iniciar con QEMU).

Ejemplo:

$ ./build.sh

Para compilar una imagen de Kali Linux adaptada para VMware. Esto significa que viene con Open VM Tools preinstalado, y la imagen producida está lista para importarse "tal cual" en VMware.

Además, la compilaremos desde la última versión estable de Kali, y usaremos GNOME como entorno de escritorio, en lugar del habitual Xfce predeterminado:

./build.sh -v vmware -b kali-last-snapshot -D gnome

Para compilar una imagen de Kali Linux diseñada para VirtualBox. Viene con las utilidades de invitado de VirtualBox preinstaladas, y la imagen se puede importar "tal cual" en VirtualBox.

Además, queremos un disco virtual de 150 GB, e instalaremos la selección de herramientas "everything":

./build.sh -v virtualbox -s 150 -S everything

Para compilar una imagen ligera de Kali, que no tiene entorno de escritorio ni conjunto de herramientas predeterminado. Esta es una imagen genérica; viene con soporte para la mayoría de los motores de VM existentes. La exportaremos al formato OVA, adecuado tanto para VMware como para VirtualBox.

Puedes instalar paquetes adicionales con la opción -P. Ya sea usando la opción varias veces (p. ej. -P pkg1 -P pkg2 ...), o dando un valor separado por comas/espacios (p. ej. -P "pkg1,pkg2, pkg3 pkg4"), o una mezcla de ambos. Instalemos también el paquete metasploit-framework:

./build.sh -v generic -f ova -D headless -P metasploit-framework

Al compilar una serie de imágenes, puede ser más conveniente (y más rápido) dividir la compilación en dos partes: primero, compilar un rootfs, y luego compilar las imágenes reutilizando este rootfs como punto de partida.

En el ejemplo siguiente, primero compilamos un rootfs kali-rolling, y luego compilamos una serie de imágenes de Vagrant:

./build.sh -b kali-rolling -v rootfs
./build.sh -r images/rootfs-rolling-amd64.tar.gz -f vagrant -v hyperv
./build.sh -r images/rootfs-rolling-amd64.tar.gz -f vagrant -v qemu
./build.sh -r images/rootfs-rolling-amd64.tar.gz -f vagrant -v virtualbox
./build.sh -r images/rootfs-rolling-amd64.tar.gz -f vagrant -v vmware

Para configurar los ajustes de teclado, usa la opción -K. El ajuste tiene la forma <layouts>/<models>/<variants>/<options>. Cada ajuste se puede omitir (en ese caso se usa el valor predeterminado), o puede tener múltiples valores separados por comas. En el caso más simple, es posible que solo quieras cambiar la distribución del teclado, por lo que pondrías us para una distribución de teclado estadounidense, de para una distribución de teclado alemana, y así sucesivamente. Explicaciones más detalladas y ejemplos se pueden encontrar en la página de manual keyboard(5). Para la lista de valores admitidos, puedes consultar el archivo /usr/share/X11/xkb/rules/xorg.lst (proporcionado por el paquete xkb-data en Debian y sistemas similares a Debian). Este archivo tiene diferentes secciones (! layout, ! model, !variant y !option) que enumeran los posibles valores para cada ajuste. También puedes comprobar qué está configurado en tu sistema con . También existe un atajo de para coincidir con el sistema anfitrión (es decir, lo que está configurado en el archivo ).

Para configurar la locale, usa la opción -L. Elige un valor en la primera columna de /usr/share/i18n/SUPPORTED, o comprueba qué está configurado en tu sistema con grep -v ^# /etc/locale.gen, o simplemente echo $LANG. También existe un atajo de -L same para coincidir con el sistema anfitrión.

Para configurar la zona horaria, usa la opción -Z. Mira en /usr/share/zoneinfo y elige un directorio y un subdirectorio. En caso de duda, ejecuta tzselect para que te guíe, o mira lo que está configurado en tu sistema con realpath /etc/localtime. También existe un atajo de -Z same para coincidir con el sistema anfitrión.

Para configurar el nombre y la contraseña del usuario sin privilegios, usa la opción -U. El valor es una sola cadena y el : se usa para separar el nombre de usuario de la contraseña.

Aquí compilaremos una imagen de Kali y la configuraremos para imitar el sistema anfitrión: misma locale, misma zona horaria y mismo nombre de usuario (con la contraseña password):

./build.sh -K same -L same -Z same -U $USER:password

Variantes y formatos

Se pueden compilar diferentes variantes de imagen, dependiendo del motor de VM en el que quieras ejecutar la imagen de Kali. La VARIANTE define principalmente qué paquete adicional se instala en la imagen, para añadir soporte para un motor de VM en particular. Luego el FORMATO define el formato del disco virtual y qué archivos de metadatos adicionales generar.

Si no se define, el formato (opción -f) se establece automáticamente según la variante (opción -v). No todas las combinaciones de variante y formato tienen sentido, por lo que la tabla siguiente intenta resumir las combinaciones más comunes.

Las imágenes generic vienen con paquetes de soporte de virtualización preinstalados para QEMU, VirtualBox y VMware, de ahí el nombre "generic". Mientras que otras imágenes, dirigidas a un motor de VM específico, solo vienen con soporte para ese motor de virtualización en particular.

Solo el formato ova define un contenedor: el resultado de la compilación es un archivo .ova, que es simplemente un archivo tar. Para otros formatos, la compilación produce archivos separados. Se pueden agrupar en un archivo 7z con la opción -z.

También existe un tipo rootfs: esto no es una imagen. Es simplemente un árbol de sistema de archivos raíz de Kali Linux, sin el kernel ni el gestor de arranque, empaquetado en un archivo .tar.gz. El caso de uso principal es reutilizarlo como entrada para compilar una imagen de sistema operativo, y no está pensado para usarse fuera del sistema de compilación.

Configuración del proxy de caché

Al compilar imágenes de sistema operativo, es útil tener un mecanismo de caché para evitar descargar todos los paquetes de Internet una y otra vez. Con este fin, el script de compilación intenta detectar proxies de caché conocidos que podrían estar ejecutándose en el host local. Primero consulta la configuración local de APT Acquire::http::Proxy. Si no está configurada, entonces intenta detectar apt-cacher-ng y squid-deb-proxy comprobando si un servicio está escuchando en su puerto predeterminado. Este mecanismo no funciona para approx (un conocido proxy de caché de APT), ya que se inicia automáticamente bajo demanda.

Para anular esta detección, puedes exportar tú mismo la variable de entorno http_proxy. Sin embargo, debes recordar que la compilación ocurre dentro de una Máquina Virtual QEMU, por lo tanto localhost en el entorno de compilación se refiere a la VM, no al host. Si quieres alcanzar el host desde la VM, probablemente quieras usar http://10.0.2.2.

Por ejemplo, si quieres usar un proxy que se ejecuta en tu máquina en el puerto 9876, usa: export http_proxy=http://10.0.2.2:9876. Si quieres asegurarte de que no se use ningún proxy, usa: export http_proxy=.

Consulta también https://github.com/go-debos/debos#environment-variables para más detalles.

Alternativamente, puedes configurar un mirror local.

Compilación y reutilización de un rootfs

Es posible dividir la compilación en dos pasos. Primero puedes compilar un rootfs con ./build.sh -v rootfs, y luego compilar una imagen basada en este rootfs con ./build.sh -r ROOTFS_NAME.tar.gz. Tiene sentido si planeas compilar varios tipos de imagen, por ejemplo.

Solución de problemas de la compilación

Memoria insuficiente

Cuando el área de trabajo temporal (scratch) se llena (es decir, el valor de --scratchsize es demasiado bajo), la compilación puede fallar con este tipo de mensajes de error:

[...]: failed to write (No space left on device)
[...]: Cannot write: No space left on device

Solución: aumenta el valor de --scratchsize. Puedes pasar argumentos a debos después del carácter especial --, así que si necesitas por ejemplo 50G, puedes hacer ./build.sh [...] -- --scratchsize=50G.

Obtener un shell en la VM cuando la compilación falla

Al depurar fallos de compilación, es conveniente obtener un shell dentro de la VM donde se realiza la compilación. Esto es posible dando la opción --debug-shell a debos: ./build.sh [...] -- --debug-shell.

Solución de problemas en tiempo de ejecución

ovf no compatible con VMware ESXI

Este es un problema conocido; consulta https://gitlab.com/kalilinux/build-scripts/kali-vm/-/work_items/25#note_1301070132 para una solución alternativa.