kalilinux/build-scripts/kali-vmScript de compilación de imágenes de VM de Kali Linux
Creador de imágenes de máquina virtual (VM) de Kali Linux, mediante debos (con fakemachine y KVM).
Estos son los mismos build-scripts que el equipo de Kali utiliza para generar las imágenes oficiales de VM de Kali Linux, disponibles en kali.org/get-kali/.
Para más información, consulta: kali.org/docs/virtualization/.
¡Construye tu Kali hoy mismo!
Recomendamos compilar en un host basado en Linux, que coincida con la arquitectura deseada.
Hay varias formas de prepararse para usar kali-vm build-script. Puedes:
build.sh - Compilar directamente desde tu máquinabuild-in-container.sh - Compilar desde dentro de un contenedor (como Docker o Podman) Para que este script funcione, requerirá KVM. Sin embargo, no se requiere acceso de superusuario. Omitiremos la habilitación de KVM en BIOS/UEFI.
La razón por la que se requiere KVM es que la compilación en realidad ocurre desde dentro de una máquina virtual (VM), que es creada sobre la marcha por la herramienta de compilación debos. Debos utiliza fakemachine internamente, que a su vez depende de QEMU+KVM.
Primero instala git, y asegúrate de que el repositorio esté clonado localmente:```console
$ sudo apt-get install --no-install-recommends
git ca-certificates
$ git clone https://gitlab.com/kalilinux/build-scripts/kali-vm.git
$ cd ./kali-vm/
- - -
Debido a los requisitos de QEMU/KVM, debes ser parte del grupo `kvm`.
Puedes verificarlo haciendo:```console
$ # Not a part 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 (por ejemplo, kali), significa que no estás en el grupo y debes añadirte al grupo kvm.
Puedes hacerlo ejecutando:```console
$ sudo adduser $USER kvm
Luego **cierra sesión y vuelve a iniciarla** para que el cambio surta efecto. <!-- That's not closing down the terminal app and re-opening it, but rather logging out of Xfce! -->
...o```console
$ newgrp kvm
Para compilar directamente en tu host, con build.sh, instala las dependencias de compilación:```console
$ sudo apt-get install --no-install-recommends
debos
linux-image-amd64
parted
dosfstools e2fsprogs
zerofree
7zip bmap-tools qemu-utils xz-utils
xkb-data
<!-- This should match what is in: [Dockerfile](https://gitlab.com/kalilinux/build-scripts/kali-vm/-/blob/main/Dockerfile) & [kali.org/docs/virtualization/](https://www.kali.org/docs/virtualization/)
Alt: $ sudo apt-get install 7zip debos dosfstools qemu-utils zerofree
xkb-data is optional, just helps to validate settings - doesn't take up that much space
-->
- - -
Ahora puedes usar `./build.sh`, que construirá una imagen de VM de Kali directamente en tu máquina.
### Construir desde dentro de un contenedor
_Omitiremos la configuración de cualquier software de contenedores._
Si prefieres construir desde dentro de un contenedor, necesitarás instalar y configurar `docker` o `podman` en tu máquina.
- `docker` requiere que el usuario se añada al grupo Docker, o usar la cuenta root (p. ej. `$ sudo ./build-in-container.sh`).
- `podman` ha sido probado tanto como rootful (p. ej. `$ sudo ./build-in-container.sh`) como rootless (p. ej. `$ ./build-in-container.sh`). Rootless además necesita `crun` (p. ej. `$ sudo apt install crun`), ya que `runc` no puede alcanzar `/dev/kvm` desde un espacio de nombres de usuario.
- - -
`build-in-container.sh` es un wrapper sobre `build.sh`. Detecta qué motor de contenedores compatible con OCI usar, se encarga de crear la [imagen del contenedor](https://gitlab.com/kalilinux/build-scripts/kali-vm/-/blob/main/Dockerfile) si falta, y luego inicia el contenedor para realizar la construcción desde dentro.
Tienes tres formas de proporcionar la imagen del contenedor:```console
$ # Option #1 - Automated build (recommended)
$ ./build-in-container.sh
$ ./build-in-container.sh --force # If you need to rebuild the image from scratch
$
$
$
$ # Option #2 - Manual build
$ docker build -t kali-build/kali-vm .
$ # ...OR...
$ podman build -t kali-build/kali-vm .
$
$
$
$ # Option #3 - Use the pre-generated
$ docker pull registry.gitlab.com/kalilinux/build-scripts/kali-vm:latest
$ docker tag registry.gitlab.com/kalilinux/build-scripts/kali-vm:latest kali-build/kali-vm
$ # ...OR...
$ podman pull registry.gitlab.com/kalilinux/build-scripts/kali-vm:latest
$ podman tag registry.gitlab.com/kalilinux/build-scripts/kali-vm:latest kali-build/kali-vm
$
$ # ...then point the build at it:
$ ./build-in-container.sh # Locally built (automated or manual)
$ IMAGE=registry.gitlab.com/kalilinux/build-scripts/kali-vm:latest ./build-in-container.sh # Pre-generated
Si tiene instalados tanto docker como podman, build-in-container.sh usará podman de forma predeterminada. Para cambiar esto, añada el prefijo CONTAINER=docker antes de ./build-in-container.sh:```console
$ CONTAINER=docker ./build-in-container.sh [...]
- - -
Ahora puedes usar `./build-in-container.sh` (en lugar de `./build.sh`), para construir una imagen.
## Ayuda```console
$ ./build.sh --help
Usage: build.sh [OPTIONS] [-- <debos options>]
Build a Kali Linux VM image.
Build options:
-a, --arch ARCH Build an image for this architecture (default: amd64)
Supported: amd64
-b, --branch BRANCH Kali branch used to build the image (default: kali-rolling)
Supported: kali-rolling kali-dev kali-last-snapshot
-f, --format FORMAT Format to export the image to (default: ...depends on --variant)
Supported: hyperv ova ovf qemu raw vagrant virtualbox vmware
-k, --keep Keep intermediary build artifacts
-m, --mirror URL Mirror used to build the image (default: http://http.kali.org/kali)
-o, --output DIR Output directory (default: /home/kali/kali-vm/output)
-r, --rootfs ROOTFS Rootfs to use to build the image (default: none)
-v, --variant VARIANT Variant of image to build, see below for details (default: generic)
Supported: generic hyperv qemu rootfs virtualbox vmware
-x, --version VERSION What to name the image release as (default: rolling)
-z, --zip Compress image and metadata files after the build
-h, --help Show this help and exit