Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Herramientas/GitLabGitLab/kalilinux/build-scripts/kali-vm
Scripting y AutomatizaciónVirtualización de SeguridadPruebas de Penetración
GitLabkalilinux/build-scripts/kali-vm

kali-vm

Script de compilación de imágenes de VM de Kali Linux

Ver Repositorio
9314936hace 27 díasRevisado por Kitploit
Compartir

Kali-VM Build-Script

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!

Requisitos previos

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áquina
  • build-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

Compilar desde el host (Kali)

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
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    708
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    500
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    398
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    341
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    259
  • 6

    antifox

    antifox-ai/antifox

    Plataforma de pruebas de penetración autónoma con múltiples agentes de IA que ejecuta reconocimiento, descubrimiento de superficie de ataque, validación de explotación y entrega de informes respaldados por evidencia.

    257

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →