Kali-VM Build-Script

Générateur d'images de machine virtuelle (VM) Kali Linux, via debos (avec fakemachine et KVM).

Ce sont les mêmes build-scripts que l'équipe Kali utilise pour générer les images officielles de VM Kali Linux, disponibles sur kali.org/get-kali/.

Pour plus d'informations, veuillez consulter : kali.org/docs/virtualization/.

Construisez votre Kali, dès aujourd'hui !

Prérequis

Nous recommandons de compiler sur un hôte Linux, correspondant à l'architecture souhaitée.

Il existe différentes façons de se préparer à utiliser le build-script kali-vm. Vous pouvez soit :

• build.sh - Compiler directement depuis votre machine
• build-in-container.sh - Compiler depuis un conteneur (tel que Docker ou Podman)

Pour que ce script fonctionne, il nécessitera KVM. Cependant, un accès super utilisateur n'est pas requis. Nous passerons outre l'activation de KVM dans le BIOS/UEFI.

La raison pour laquelle KVM est requis est que la compilation se déroule en réalité depuis une machine virtuelle (VM), créée à la volée par l'outil de compilation debos. Debos utilise fakemachine en arrière-plan, qui à son tour repose sur QEMU+KVM.

---

Commencez par installer git, et assurez-vous que le dépôt est cloné localement :```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/

En raison des exigences de QEMU/KVM, vous devez faire partie du groupe `kvm`.
Vous pouvez vérifier en faisant :```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 votre nom d'utilisateur n'apparaît pas dans la ligne retournée (par exemple kali), cela signifie que vous ne faites pas partie du groupe, et vous devez vous ajouter vous-même au groupe kvm. Vous pouvez le faire en exécutant :```console $ sudo adduser $USER kvm

Puis **déconnectez-vous et reconnectez-vous** pour que le changement prenne effet. <!-- That's not closing down the terminal app and re-opening it, but rather logging out of Xfce! -->
...ou```console
$ newgrp kvm

Compiler depuis l'hôte (Kali)

Pour compiler directement sur votre hôte, avec build.sh, installez les dépendances de compilation :```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
-->

- - -

Vous pouvez maintenant utiliser `./build.sh`, qui construira une image de VM Kali directement sur votre machine.

### Construire depuis un conteneur

_Nous passerons la configuration de tout logiciel de conteneur._

Si vous préférez construire depuis un conteneur, vous devrez installer et configurer soit `docker`, soit `podman` sur votre machine.

- `docker` nécessite que l'utilisateur soit ajouté au groupe Docker, ou l'utilisation du compte root (par exemple `$ sudo ./build-in-container.sh`).
- `podman` a été testé à la fois en rootful (par exemple `$ sudo ./build-in-container.sh`) et en rootless (par exemple `$ ./build-in-container.sh`). Le mode rootless nécessite en plus `crun` (par exemple `$ sudo apt install crun`), car `runc` ne peut pas atteindre `/dev/kvm` depuis un namespace utilisateur.

- - -

`build-in-container.sh` est un wrapper au-dessus de `build.sh`. Il détecte quel moteur de conteneur conforme à OCI utiliser, se charge de créer l'[image de conteneur](https://gitlab.com/kalilinux/build-scripts/kali-vm/-/blob/main/Dockerfile) si elle est absente, puis démarre le conteneur pour effectuer la construction depuis celui-ci.

Vous avez trois façons de fournir l'image de conteneur :```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 vous avez à la fois docker et podman installés, build-in-container.sh utilisera par défaut podman. Pour changer cela, préfixez CONTAINER=docker avant ./build-in-container.sh :```console $ CONTAINER=docker ./build-in-container.sh [...]

- - -

Vous pouvez maintenant utiliser `./build-in-container.sh` (plutôt que `./build.sh`), pour construire une image.

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