Kali-VM Build-Script

Kali Linux Virtual Machine (VM)-Image-Builder, via debos (mit fakemachine und KVM).

Dies sind dieselben Build-Skripte, die das Kali-Team verwendet, um die offiziellen Kali Linux VM-Images zu erstellen, die auf kali.org/get-kali/ zu finden sind.

Weitere Informationen finden Sie unter: kali.org/docs/virtualization/.

Erstellen Sie Ihr Kali, noch heute!

Voraussetzungen

Wir empfehlen, auf einem Linux-basierten Host zu bauen, der der gewünschten Architektur entspricht.

Es gibt verschiedene Möglichkeiten, sich für die Verwendung des kali-vm Build-Skripts vorzubereiten. Sie können entweder:

• build.sh - Direkt von Ihrer Maschine aus bauen
• build-in-container.sh - Aus einem Container heraus bauen (wie Docker oder Podman)

Damit dieses Skript funktioniert, wird KVM benötigt. Superuser-Zugriff ist jedoch nicht erforderlich. Wir überspringen die Aktivierung von KVM im BIOS/UEFI.

Der Grund, warum KVM erforderlich ist, liegt darin, dass der Build tatsächlich innerhalb einer virtuellen Maschine (VM) stattfindet, die vom Build-Tool debos on-the-fly erstellt wird. Debos verwendet intern fakemachine, das wiederum auf QEMU+KVM angewiesen ist.

---

Installieren Sie zunächst git und stellen Sie sicher, dass das Repository lokal geklont ist:```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/

- - -

Aufgrund der Anforderungen von QEMU/KVM müssen Sie Teil der Gruppe `kvm` sein.
Sie können dies überprüfen mit:```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
$

Wenn Ihr Benutzername nicht in der zurückgegebenen Zeile erscheint (z. B. kali), bedeutet das, dass Sie nicht in der Gruppe sind, und Sie müssen sich selbst zur Gruppe kvm hinzufügen. Sie können das tun, indem Sie Folgendes ausführen:```console $ sudo adduser $USER kvm

Dann **melde dich ab und wieder an**, damit die Änderung wirksam wird. <!-- That's not closing down the terminal app and re-opening it, but rather logging out of Xfce! -->
...oder```console
$ newgrp kvm

Vom Host aus bauen (Kali)

Um direkt auf deinem Host mit build.sh zu bauen, installiere die Build-Abhängigkeiten:```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
-->

- - -

Jetzt können Sie `./build.sh` verwenden, wodurch ein Kali-VM-Image direkt auf Ihrer Maschine erstellt wird.

### Aus einem Container heraus erstellen

_Wir überspringen die Einrichtung jeglicher Container-Software._

Wenn Sie es vorziehen, aus einem Container heraus zu erstellen, müssen Sie entweder `docker` oder `podman` auf Ihrer Maschine installieren und konfigurieren.

- `docker` erfordert, dass der Benutzer zur Docker-Gruppe hinzugefügt wird oder das Root-Konto verwendet wird (z. B. `$ sudo ./build-in-container.sh`).
- `podman` wurde sowohl als rootful (z. B. `$ sudo ./build-in-container.sh`) als auch als rootless (z. B. `$ ./build-in-container.sh`) getestet. Rootless benötigt zusätzlich `crun` (z. B. `$ sudo apt install crun`), da `runc` aus einem User-Namespace heraus nicht auf `/dev/kvm` zugreifen kann.

- - -

`build-in-container.sh` ist ein Wrapper über `build.sh`. Es erkennt, welche OCI-konforme Container-Engine verwendet werden soll, kümmert sich um die Erstellung des [Container-Images](https://gitlab.com/kalilinux/build-scripts/kali-vm/-/blob/main/Dockerfile), falls es fehlt, und startet dann den Container, um den Build von innen heraus durchzuführen.

Sie haben drei Möglichkeiten, das Container-Image bereitzustellen:```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

Wenn sowohl docker als auch podman installiert sind, verwendet build-in-container.sh standardmäßig podman. Um dies zu ändern, stellen Sie CONTAINER=docker vor ./build-in-container.sh:```console $ CONTAINER=docker ./build-in-container.sh [...]

- - -

Jetzt können Sie `./build-in-container.sh` (statt `./build.sh`) verwenden, um ein Image zu erstellen.

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