Cómo instalar Kali en una memoria USB con arranque EFI puro en una Mac (y agreguemos la virtualización ...

Este tutorial es para todos los que quieran una memoria USB con una instalación completa de Kali para usar con su (s) Mac (s). Esto no pretende realizar una instalación de Live Kali con persistencia.

El problema cuando realiza una instalación de Kali en una memoria USB es que Kali divide el disco con el sistema de archivos VFAT. Mac OS solo reconoce particiones HFS + junto con algunos archivos necesarios para ello.

Así que tú necesitas:

  • Tu Mac
  • Una memoria USB con el instalador Kali ISO
  • Una memoria USB de destino, una tarjeta SD o una unidad externa SSD donde instalará Kali (se recomiendan 16 GB y USB 3.0)

Este tutorial se inspiró en gran medida en este tutorial con correcciones adecuadas para Kali. //medium.com/@mmiglier/ubuntu-installation-on-usb-stick-with-pure-efi-boot-mac-compatible-469ad33645c9

Instalación USB Live

En primer lugar, instale Kali en una memoria USB siguiendo este tutorial. No voy a molestarlo sobre cómo proceder en este paso, pero comience aquí:

$ sudo dd if={KALI_ISO.iso} of=/dev/{USB} bs=1m 

Cuando esté listo, reinicie su Mac. Inserte ambas memorias USB, luego presione ALT y seleccione el arranque EFI para iniciar el instalador en vivo.

El instalador de Kali le hará diferentes preguntas sobre su zona horaria y la distribución del teclado.

Continúe hasta que le pida que particione los discos, aquí seleccione: Manual. Luego, seleccione su unidad de destino USB (donde desea instalar Kali). Se puede reconocer por varios factores, por ejemplo por su tamaño. Haga clic en Continuar: esto dividirá su disco.

Ahora, regrese nuevamente a la misma pantalla y seleccione el ESPACIO LIBRE debajo de la unidad de destino USB. Haga clic en Continuar y seleccione Particionar automáticamente el espacio libre. Siga la opción recomendada. Luego haga clic en Finalizar particionamiento y escriba el cambio en el disco .

El proceso de instalación ahora copiará los datos al disco. Espere hasta que termine (esto tomará ~ 30 minutos).

Arrancar desde GRUB Live

Una vez finalizado, tu Mac se reiniciará y tendrás que presionar ALT nuevamente. Seleccione de nuevo EFI boot .

Lo que tenemos que hacer ahora es cargar nuestro sistema Kali instalado a través de Live GRUB , porque nuestro sistema instalado no tiene un cargador de arranque reconocible por MacOS.

Una vez que se haya cargado GRUB, presione c para obtener la interfaz de línea de comandos de GRUB.

Ahora debes entender en qué HD es tu instalación de Kali. Para hacer esto, cuando se cargue GRUB cli, escriba ls ; expulsa tu memoria USB y escribe ls de nuevo.

grub> ls (memdisk) (hd0) (hd1) (hd1,gpt3) (hd1, gpt2) (hd1,gpt1) ...

Notará que un hd {X} desapareció: ese es su disco. Ahora tienes que encontrar tu gpt. Probablemente sea el gpt2 , pero solo para estar seguro, escriba:

grub> ls (hdX,gpt2)/boot/grub unicode.pf2 ...

Si el comando dice unicode..que es el gpt correcto; intente con otros gpts de lo contrario. Ahora busque su UUID de la partición y anótelo.

grub> ls -l (hdX},gpt{X}) Partition hd2,gpt2: Filesystem type ext* 〈...snip...〉 UUID e86c20b9-83e1-447d-a3be-d1ddaad6c4c6 - Partition start at [...]

Ahora no podemos establecer los parámetros en GRUB para arrancar (use la tecla de tabulación para usar autocompletar):

grub> set root=(hd{X},gpt{X}) grub> linux /boot/vmlinuz〈...tab here!...〉.efi.signed root=UUID=〈the UUID〉 grub> initrd /boot/initrd〈...tab here!...〉 grub> boot

Esto debería iniciar su instalación completa de Kali usando Live GRUB. Puede diferenciarse del entorno Live por la contraseña que reconoce durante el proceso de inicio de sesión.

Arreglando la partición EFI

Una vez que haya iniciado sesión en su instalación de Kali, abra la Terminal y escriba:

$ fdisk -l

y encuentra tu disco.

Ahora, abra gdisk (instalado por defecto en Kali) para particionar el disco (tenga mucho cuidado aquí):

$ gdisk /dev/sd{X} GPT fdisk (gdisk) version 1.0.1 Partition table scan: MBR: hybrid BSD: not present APM: not present GPT: present Found valid GPT with hybrid MBR; using GPT. Command (? for help):

Imprima la tabla de particiones y confirme que la primera partición tenga el tipo EF00:

Command (? for help): p Disk /dev/sdd: ... [...] Number Start (sector) End (sector) Size Code Name 1 2048 1050623 512.0 MiB EF00 EFI System Partition [...]

Ahora tenemos que:

  • eliminar esa partición EF00
  • crear un nuevo HFS + una vez en su lugar
Command (? for help): d Partition number (1-3): 1 Command (? for help): n Partition number (1-128, default 1): 1 Just leave defaults values in the sector phase Current type is 'Linux filesystem' Hex code or GUID (L to show codes, Enter = 8300): AF00 Changed type of partition to 'Apple HFS/HFS+' Command (? for help): w Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING PARTITIONS!! Do you want to proceed? (Y/N): Y OK; writing new GUID partition table (GPT) to /dev/sdd. Warning: The kernel is still using the old partition table. The new table will be used at the next reboot. The operation has completed successfully.

Ahora tenemos una partición HFS + sin formato. Para formatear, necesitamos algunas herramientas; pero para obtener estas herramientas necesitamos agregar la lista de fuentes de Debian a apt.

$ echo "deb //ftp.debian.org/debian unstable main contrib non-free" > /etc/apt/sources.list.d/debian.list $ apt update $ apt install hfsprogs

Podemos formatear esa partición:

$ mkfs.hfsplus /dev/sd{X}1 -v Kali Initialized /dev/sd{X}1 as a 512 MB HFS Plus volume

Ahora tenemos que editar el archivo / etc / fstab :

$ gedit /etc/fstab

Esto iniciará Gedit. En este archivo, localice estas líneas:

# / boot / efi estaba en / dev / sd {X} 1 durante la instalación

UUID = {XXXXXXX} / boot / efi vfat valores predeterminados 0 1

y eliminarlos.

Ahora, desmonte la partición de arranque, localizándola usando:

$ mount | grep /boot/efi /dev/sd{Y}1 on /boot/efi ... $ umount /dev/sd{Y}1

Luego ejecute esto para agregar las entradas necesarias a su archivo fstab:

$ echo "UUID=$(blkid -o value -s UUID /dev/sd{X}1) /boot/efi auto defaults 0 0" >> /etc/fstab

Now we have to reinstall GRUB so it can use the newly formatted HFS+ partition for its EFI data:

$ mkdir -p /boot/efi/EFI/Kali $ echo "This file is required for booting" > /boot/efi/EFI/Kali/mach_kernel $ echo "This file is required for booting" > /boot/efi/mach_kernel $ grub-install --target x86_64-efi --boot-directory=/boot --efi-directory=/boot/efi --bootloader-id=Kali

We then need to “bless” the bootloader code, so that the Mac bootloader will boot it. To do that we need hfsbless binary that is not available via apt. No problem, just clone the repository and build:

$ cd /root $ git clone //github.com/detly/mactel-boot $ cd mactel-boot $ make

Then bless:

./hfs-bless /boot/efi/EFI/Kali/System/Library/CoreServices/boot.efi

The final step is to create the grub configuration:

$ sed -i 's/GRUB_HIDDEN/#GRUB_HIDDEN/g' /etc/default/grub $ sed -i 's/GRUB_TIMEOUT=10/GRUB_TIMEOUT=0.1/' /etc/default/grub $ grub-mkconfig -o /boot/grub/grub.cfg

Perfecto! Now reboot and you should see your USB stick in the Mac bootloader by pressing ALT.

Virtualizing the USB via Virtualbox

If you ever need to boot this USB stick via Virtualbox (on Mac OSX), there is a simple trick to do that.

First of all, you’ve to create a VMDK disk that points to the sectors of your USB stick. So, let’s identify that disk:

$ diskutil list /dev/disk0 (internal): #: TYPE NAME SIZE IDENTIFIER 0: GUID_partition_scheme 500.3 GB disk0 1: EFI EFI 314.6 MB disk0s1 2: Apple_APFS Container disk1 499.3 GB disk0s2 /dev/disk1 (synthesized): #: TYPE NAME SIZE IDENTIFIER 0: APFS Container Scheme - +499.3 GB disk1 Physical Store disk0s2 1: APFS Volume Macintosh HD 222.0 GB disk1s1 2: APFS Volume Preboot 22.4 MB disk1s2 3: APFS Volume Recovery 519.9 MB disk1s3 4: APFS Volume VM 3.2 GB disk1s4 /dev/disk3 (external, physical): #: TYPE NAME SIZE IDENTIFIER 0: GUID_partition_scheme *32.0 GB disk3

In our case, it is /dev/disk3. Let’s unmount before proceeding:

$ diskutil unmountDisk /dev/disk{X}

With VirtualBox installed, run:

$ sudo VBoxManage internalcommands createrawvmdk -filename ~/Kali.vmdk -rawdisk /dev/disk{X} $ chmod 777 ~/Kali.vmdk $ chmod 777 /dev/disk{X}

Perfecto. Now, run Virtualbox UI and create a new machine with the following settings:

When VirtualBox asks you for a disk, let’s point to that VMDK created before:

Before starting up the machine, let’s go to Settings and adjust your process counts, video and memory.

The important things are to set Enable EFI under System > Motherboard.

This will allow you to boot via EFI. Now start the virtual machine and immediately press F12.

Select Boot Maintenance Manager:

Select Boot from file:

Then select {SATA_DRIVE} > EFI > Kali > System > Library > CoreServices > boot.efi

And, voilà:

Stay tuned :)