Kali-VM Build-Script

Construtor de imagem de Máquina Virtual (VM) do Kali Linux, via debos (com fakemachine e KVM).

Estes são os mesmos build-scripts que a equipe do Kali usa para gerar as imagens oficiais de VM do Kali Linux, encontradas em kali.org/get-kali/.

Para mais informações, consulte: kali.org/docs/virtualization/.

Construa o seu Kali, hoje mesmo!

Pré-requisitos

Recomendamos construir em um host baseado em Linux, que corresponda à arquitetura desejada.

Existem várias maneiras de se preparar para usar o kali-vm build-script. Você pode:

• build.sh - Construir diretamente da sua máquina
• build-in-container.sh - Construir de dentro de um contêiner (como Docker ou Podman)

Para este script funcionar, será necessário KVM. No entanto, acesso de superusuário não é necessário. Vamos pular a parte de habilitar o KVM na BIOS/UEFI.

A razão pela qual o KVM é necessário é que a construção na verdade acontece de dentro de uma máquina virtual (VM), que é criada em tempo real pela ferramenta de construção debos. O Debos usa o fakemachine por baixo dos panos, que por sua vez depende do QEMU+KVM.

---

Primeiro instale o git, e certifique-se de que o repositório esteja 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/

- - -

Devido aos requisitos do QEMU/KVM, você deve fazer parte do grupo `kvm`.
Você pode verificar fazendo:```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 o seu nome de usuário não aparecer na linha retornada (por exemplo, kali), significa que você não está no grupo, e você deve adicionar-se ao grupo kvm. Você pode fazer isso executando:```console $ sudo adduser $USER kvm

Em seguida, **faça logout e login novamente** para que a alteração tenha efeito. <!-- That's not closing down the terminal app and re-opening it, but rather logging out of Xfce! -->
...ou```console
$ newgrp kvm

Compilar a partir do host (Kali)

Para compilar diretamente no seu host, com build.sh, instale as dependências de compilação:```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
-->

- - -

Agora você pode usar `./build.sh`, que irá construir uma imagem de VM Kali diretamente na sua máquina.

### Construir de Dentro de um Contêiner

_Vamos pular a configuração de qualquer software de contêiner._

Se você preferir construir de dentro de um contêiner, precisará instalar e configurar `docker` ou `podman` na sua máquina.

- `docker` requer que o usuário seja adicionado ao grupo Docker, ou o uso da conta root (por exemplo, `$ sudo ./build-in-container.sh`).
- `podman` foi testado tanto como rootful (por exemplo, `$ sudo ./build-in-container.sh`) quanto rootless (por exemplo, `$ ./build-in-container.sh`). O modo rootless adicionalmente precisa do `crun` (por exemplo, `$ sudo apt install crun`), pois o `runc` não consegue acessar `/dev/kvm` a partir de um namespace de usuário.

- - -

`build-in-container.sh` é um wrapper em cima do `build.sh`. Ele detecta qual mecanismo de contêiner compatível com OCI usar, encarrega-se de criar a [imagem do contêiner](https://gitlab.com/kalilinux/build-scripts/kali-vm/-/blob/main/Dockerfile) caso esteja faltando, e então inicia o contêiner para realizar a construção de dentro dele.

Você tem três maneiras de fornecer a imagem do contêiner:```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 você tiver tanto docker quanto podman instalados, build-in-container.sh usará podman por padrão. Para alterar isso, prefixe CONTAINER=docker antes de ./build-in-container.sh:```console $ CONTAINER=docker ./build-in-container.sh [...]

- - -

Agora você pode usar `./build-in-container.sh` (em vez de `./build.sh`), para construir uma imagem.

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