Kali-VM Build-Script

Kali Linux Virtual Machine (VM) image builder, via debos (con fakemachine e KVM).

Questi sono gli stessi build-scripts che il team di Kali utilizza per generare le immagini ufficiali di Kali Linux VM, disponibili su kali.org/get-kali/.

Per maggiori informazioni, consulta: kali.org/docs/virtualization/.

Crea la tua Kali, oggi stesso!

Prerequisiti

Consigliamo di eseguire la build su un host basato su Linux, che corrisponda all'architettura desiderata.

Ci sono vari modi per prepararsi all'uso di kali-vm build-script. Puoi:

• build.sh - Esegui la build direttamente dalla tua macchina
• build-in-container.sh - Esegui la build all'interno di un container (come Docker o Podman)

Per funzionare, questo script richiede KVM. Tuttavia, non è necessario l'accesso come super utente. Ometteremo l'abilitazione di KVM nel BIOS/UEFI.

Il motivo per cui KVM è necessario è che la build avviene effettivamente all'interno di una macchina virtuale (VM), creata al volo dallo strumento di build debos. Debos utilizza fakemachine sotto il cofano, che a sua volta si basa su QEMU+KVM.

---

Per prima cosa installa git e assicurati che il repository sia clonato 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/

A causa dei requisiti di QEMU/KVM, devi far parte del gruppo `kvm`.
Puoi verificarlo eseguendo:```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
$

Se il tuo nome utente non compare nella riga restituita (ad es. kali), significa che non fai parte del gruppo e devi aggiungerti al gruppo kvm. Puoi farlo eseguendo:```console $ sudo adduser $USER kvm

Poi **esci e accedi di nuovo** affinché la modifica abbia effetto. <!-- Non si tratta di chiudere l'app del terminale e riaprirla, ma di uscire da Xfce! -->
...oppure```console
$ newgrp kvm

Compilazione dall'host (Kali)

Per compilare direttamente sul tuo host, con build.sh, installa le dipendenze di compilazione:```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
-->

- - -

Ora puoi usare `./build.sh`, che costruirà un'immagine VM Kali direttamente sulla tua macchina.

### Build dall'interno di un container

_Salteremo la configurazione di qualsiasi software per container._

Se preferisci eseguire la build dall'interno di un container, dovrai installare e configurare `docker` o `podman` sulla tua macchina.

- `docker` richiede che l'utente sia aggiunto al gruppo Docker, oppure l'utilizzo dell'account root (ad esempio `$ sudo ./build-in-container.sh`).
- `podman` è stato testato sia come rootful (ad esempio `$ sudo ./build-in-container.sh`) che rootless (ad esempio `$ ./build-in-container.sh`). Rootless richiede inoltre `crun` (ad esempio `$ sudo apt install crun`), poiché `runc` non riesce a raggiungere `/dev/kvm` da un namespace utente.

- - -

`build-in-container.sh` è un wrapper sopra `build.sh`. Rileva quale motore di container conforme a OCI utilizzare, si occupa di creare l'[immagine del container](https://gitlab.com/kalilinux/build-scripts/kali-vm/-/blob/main/Dockerfile) se mancante, e poi avvia il container per eseguire la build dall'interno.

Hai tre modi per fornire l'immagine del container:```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

---

Se hai sia docker che podman installati, build-in-container.sh utilizzerà podman per impostazione predefinita. Per modificare questa impostazione, anteponi CONTAINER=docker prima di ./build-in-container.sh:```console $ CONTAINER=docker ./build-in-container.sh [...]

- - -

Ora puoi usare `./build-in-container.sh` (invece di `./build.sh`), per creare un'immagine.

## Aiuto```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