I AM  LAWALI AM  LAWAL

← All labs

The Foundation Lab: One Security Lab Environment on Apple Silicon

The shared base every lab in this portfolio builds on: UTM on an Apple Silicon Mac, an ARM-native Kali attacker, an Ubuntu Server box for the SIEM, x86 targets under emulation, an isolated network, and snapshots. Set it up once, then branch into any track.

1 October 2026·15 min read·Self-hosted lab
Platform
Self-hosted
Target
Local VM lab
Difficulty
Easy
OS
Linux
Tools
  • UTM
  • QEMU
  • Kali Linux
  • Ubuntu Server
Skills
  • virtualization
  • networking
  • lab-setup
  • snapshots
The UTM app on macOS showing the lab's virtual machines: an ARM Kali attacker and emulated x86 targets on an isolated network.

On this page

  1. Why this lab exists
  2. The one concept that makes this work
  3. Lab architecture
  4. Prerequisites
  5. Why UTM and not something else
  6. 1. The Kali attacker VM (ARM64, Virtualize)
  7. 2. The Ubuntu Server VM (ARM64, Virtualize)
  8. 3. Adding x86 target VMs (Emulate)
  9. 4. Networking: the Shared Network
  10. 5. RAM budget
  11. 6. Snapshots, before you break anything
  12. Connecting to old targets over SSH
  13. Where to go next
  14. Appendix A: Troubleshooting reference
  15. Appendix B: VM quick reference
  16. Appendix C: Screenshot checklist
  17. Lab status

Every lab in this portfolio, offensive and defensive, runs on the same small set of virtual machines on a single Apple Silicon Mac. This guide stands that environment up once. Finish it and you have a working attacker box, a server for the detection stack, a pattern for adding vulnerable targets, and an isolated network for them to talk on. From here you branch into any track without rebuilding setup.

If you have already done the environment setup inside another lab, you can skip this one. It is the same ground, pulled out into its own place so the track guides can point here instead of repeating it.


Why this lab exists#

Most security lab guides assume an Intel machine running VirtualBox. On an Apple Silicon Mac they break at step one: VirtualBox cannot run x86 guests on ARM at all. Parallels (paid) and VMware Fusion (free for personal use) are more polished, but they virtualize rather than emulate, so regardless of cost neither can boot the old x86 systems most vulnerable VMs are built for.

The whole training ecosystem of intentionally vulnerable boxes is x86. The real problem on an ARM Mac is not the attacking, it is getting those targets to run at all. This foundation solves that with UTM, a free, open-source hypervisor that can both virtualize ARM-native guests at full speed and emulate x86 guests slowly but faithfully, on the same machine and the same isolated network. No paid software, no Intel hardware.


The one concept that makes this work#

UTM offers two ways to run a guest, and picking the wrong one means the VM will not boot. This single distinction governs every machine you add:

  • Virtualize runs a guest on the Mac's own ARM CPU directly. Fast, near-native. Use it for anything ARM64: Kali, Ubuntu Server.
  • Emulate translates another architecture instruction by instruction. Slower, but it runs x86 operating systems that have no ARM build. Use it for every VulnHub or Metasploitable-style target.

A plain rule to carry through the whole portfolio: ARM64 guest → Virtualize. x86 guest → Emulate. When a target download is an .ova, .vmdk, or an old ISO, it is almost always x86, so it is Emulate.


Lab architecture#

One environment, two ways to run a machine UTM virtualises ARM-native guests at full speed and emulates x86 targets faithfully, all on one isolated network. macOS host: Apple Silicon Mac (ARM64) · UTM / QEMU Kali Linux attacker · 192.168.64.2 VIRTUALIZE (ARM64) Native speed: shares the host CPU architecture. Ubuntu Server SIEM host · 192.168.64.3 VIRTUALIZE (ARM64) Hosts the detection stack for the blue-team tracks. x86 targets victims · 192.168.64.4–.6 EMULATE (x86) Old vulnerable boxes on a translated x86 CPU. UTM Shared Network · isolated 192.168.64.0/24 (NAT, walled off from your LAN) The rule that governs every VM you add: ARM64 goes Virtualize (fast), x86 goes Emulate (slower, but it boots). VirtualBox, Parallels and VMware Fusion only virtualise, so they cannot run an x86 target on ARM at all. UTM emulates one for free, which is what lets the whole classic x86 training ecosystem run on an Apple Silicon Mac.

The addresses above are the convention this portfolio uses throughout. Yours may differ by a digit; what matters is that every VM sits on the same Shared Network.


Prerequisites#

RequirementMinimumRecommended
Mac chipAny Apple Silicon (M1+)M2 Pro or later
RAM16 GB16 GB+ (you will run 2–3 VMs at once)
Storage80 GB free150 GB+ free
SoftwareUTM (free)UTM + Homebrew
NetworkInternet for downloads and feed syncsShared Network (default)

Install qemu-img (used to convert target disks later):

brew install qemu

Why UTM and not something else#

HypervisorFree?Runs on Apple Silicon?Can emulate x86?Verdict
UTMYesYes (native)Yes (QEMU backend)The only free option that does both
VirtualBoxYesPartial (Dev Preview)Nox86 VMs will not boot
VMware FusionFree tierYesNoARM guests only
ParallelsPaid (~$100/yr)YesNoARM guests only
DockerYesYesN/ANot a hypervisor, cannot run full OS VMs

The tradeoff with UTM is speed: emulated x86 VMs run slower because every instruction is translated. For a security lab that is fine. You are running scans, shells, and log pipelines, not compiling kernels.

Install UTM: download from mac.getutm.app or the Mac App Store.


1. The Kali attacker VM (ARM64, Virtualize)#

Kali publishes an official ARM64 image, so this VM runs natively.

  1. Download the Kali Linux ARM64 installer from kali.org/get-kali (the Apple Silicon image).
  2. Open UTM → Create a New Virtual Machine → Virtualize (not Emulate).
  3. Configure:
    • OS: Linux
    • RAM: 4 GB minimum (6–8 GB if your Mac has 32 GB+)
    • Storage: 40 GB (Kali plus tooling needs room)
    • Network: Shared Network (critical, see section 4)
  4. Attach the ISO and save the VM. Do not start the installer yet.

Do not use the graphical installer here. GRUB appears as normal, but after you pick Graphical install the screen can change to "Display output is not active" and stay there. Kali's UTM guide puts this down to a UTM bug and installs in console mode instead, so that is what these steps do:

  1. Shut down the Kali VM if it is running, and open its settings.
  2. Under Devices, click New and add a Serial device. Save.
  3. Start the VM.
  4. In GRUB, choose Install, not Graphical install.
  5. Complete the installer in the Serial window.
  6. When the install finishes, shut down the VM.
  7. Open USB Drive in settings and click Clear to remove the ISO. Otherwise the VM boots the installer again.
  8. Remove the Serial device.
  9. Set the display card to virtio-gpu-pci, then boot.

If the screen stays blank at step 5: switch the VM window's display to the Serial device, and give it a moment to start.

Checkpoint: after first boot, open a terminal and run:

uname -m

Expected output is aarch64. That confirms you are running native ARM, not emulation.

Tick each box once you have captured that shot; it syncs with the screenshot checklist automatically.


2. The Ubuntu Server VM (ARM64, Virtualize)#

This box becomes the host for the detection stack in the SIEM track (Wazuh manager, indexer, dashboard). It is ARM-native, so it also virtualizes. Build it now if you plan to do any blue-team work; skip it if you are only doing the pentest track for now.

  1. Download Ubuntu Server for ARM64 from ubuntu.com/download/server/arm.
  2. UTM → Create a New Virtual Machine → Virtualize.
  3. Configure:
    • OS: Linux
    • RAM: 6 GB (the SIEM's indexer is memory-hungry)
    • Storage: 64 GB (log data grows)
    • Network: Shared Network
  4. Run the guided installer. Create a user and enable OpenSSH when prompted so you can manage it from your Mac terminal.

Watch the disk sizing. UTM's guided Ubuntu install often assigns only about half the disk to the root volume through LVM, leaving the rest unallocated. Check right after install:

df -h /
lsblk

If / is far smaller than the disk you gave it, extend the logical volume into the free space:

sudo lvextend -l +100%FREE /dev/ubuntu-vg/ubuntu-lv
sudo resize2fs /dev/ubuntu-vg/ubuntu-lv

Checkpoint: df -h / now shows close to the full disk, and uname -m reports aarch64.

Tick each box once you have captured that shot; it syncs with the screenshot checklist automatically.


3. Adding x86 target VMs (Emulate)#

Vulnerable boxes ship as x86 disk images. The import workflow is the same for every one: convert the disk, create an emulated VM, and point it at the converted disk. Learn it once and you can bring in anything.

Example: Metasploitable 2

  1. Download the box (for example from vulnhub.com).
  2. Extract the .vmdk, then convert it to QEMU's format:
    qemu-img convert -O qcow2 Metasploitable.vmdk Metasploitable.qcow2
  3. UTM → Create a New Virtual Machine → Emulate.
    • Architecture: x86_64
    • RAM: 512 MB–1 GB (these boxes are light)
    • Do not check UEFI Boot. Old Linux images expect BIOS; UEFI drops you into a shell instead of booting.
  4. Instead of creating a new disk, import your .qcow2 as the drive.
  5. Set the network to Shared Network, then boot.

If the screen says "Display output is not active": this is not a hang. Old kernels lack a driver for UTM's default display card. Shut down, go to Settings → Display, and switch the card to plain VGA.

Checkpoint: the target reaches its login banner. It does not need to log in to be useful; many lab targets are attacked over the network only.

Tick each box once you have captured that shot; it syncs with the screenshot checklist automatically.


4. Networking: the Shared Network#

Every lab VM must be on the same UTM network mode to see the others. Use Shared Network for all of them.

ModeWhat it doesUse it?
Shared NetworkAll VMs get IPs on the same 192.168.64.0/24 subnet, NAT'd through the MacYes, use this
BridgedPuts the VM on your real LANNo, this exposes deliberately vulnerable boxes to your real network
Host OnlyIsolates VMs; VM-to-VM access needs a shared host network with manually assigned IPsNot covered here

"Isolated" means isolated from your LAN, not air-gapped. Shared Network is NAT: your VMs cannot be reached inbound from your real network, but they can reach the internet outbound through the Mac. That path is what Kali and the Ubuntu Server box need for updates and feed syncs, which is why the labs use it. It does mean a deliberately vulnerable target has outbound internet the whole time it runs, and powering it off only removes that exposure while it is off, not during a session. If you want the target genuinely cut off, do not leave Shared Network as its only interface: put it on a Host Only network and reach it from Kali over a second host-only interface, or add an outbound-deny firewall rule on the target itself. Both are fiddlier and not covered here. For a throwaway box behind NAT that you power off when idle, Shared Network is the pragmatic balance, but treat the internet exposure as real while a session is live.

Confirm connectivity after booting two VMs:

# From Kali
ip addr show        # note Kali's IP, e.g. 192.168.64.2
TARGET=192.168.64.4 # the target's IP; find it with ip addr on the target VM
ping "$TARGET"

Checkpoint: you get ping replies. If not, confirm both VMs are set to Shared Network and check each one's actual IP with ip addr.

Tick each box once you have captured that shot; it syncs with the screenshot checklist automatically.


5. RAM budget#

On a 16 GB Mac you cannot run everything at once. Plan sessions around what a task needs:

SessionWhat is runningApprox. RAM
PentestKali (4 GB) + 1 target (1 GB)~5 GB
DetectionKali (4 GB) + Ubuntu Server (6 GB) + 1 target (1 GB)~11 GB
Multi-targetKali (4 GB) + 2 targets (1 GB each)~6 GB

Rule of thumb: Kali plus the SIEM server plus one target is the comfortable ceiling on 16 GB. A second target on top of that gets tight. Running every VM at once will swap and crawl.


6. Snapshots, before you break anything#

UTM has no built-in snapshot GUI. Two reliable options:

Option A, file-level copy (simplest):

  1. Shut the VM down.
  2. In Finder, open ~/Library/Containers/com.utmapp.UTM/Data/Documents/.
  3. Duplicate the whole .utm bundle and rename the copy (for example Metasploitable-clean.utm).

Option B, QEMU snapshot (lighter):

# VM must be stopped for both commands
qemu-img snapshot -c clean-install /path/to/disk.qcow2   # create
qemu-img snapshot -a clean-install /path/to/disk.qcow2   # restore (apply)
qemu-img snapshot -l /path/to/disk.qcow2                 # list snapshots

Do this while each box is clean, before any exploitation or configuration changes. A clean snapshot is what lets you reset a target to a known state: after a run, stop the VM and apply the snapshot with -a to roll it back.

Tick each box once you have captured that shot; it syncs with the screenshot checklist automatically.


Connecting to old targets over SSH#

The older x86 boxes run SSH versions whose key-exchange and host-key algorithms modern OpenSSH refuses by default. Re-enable exactly the ones a given target needs when you connect from Kali:

ssh -oHostKeyAlgorithms=+ssh-rsa -oPubkeyAcceptedAlgorithms=+ssh-rsa user@192.168.64.x

Add only what the handshake error asks for. Do not re-enable ssh-dss; newer OpenSSH removed it for good reason, and no lab target here needs it.


Where to go next#

The environment is now the shared base for every track. You do not need all the VMs for every one, so build what a track needs when you need it. This is the hub; each track below is a spoke. See how they connect on the interactive labs map, or jump straight in:

LOCAL · UTM ON APPLE SILICON Foundation UTM, network, Kali setup Pentest Lab Recon to root on a box Detection & SIEM Wazuh, Suricata and FIM Phishing Bridge Planned: run it, then detect it AI-Augmented SOC Planned: detection, run with AI Dashed link = shared topology (phishing reuses the pentest target)
  • Pentest track: recon to root against the x86 targets, two independent paths, every offensive step paired with the control that stops it. Uses Kali and the targets. (Published.)
  • Detection & SIEM track: stand up Wazuh on the Ubuntu Server box, ship agent and network logs, and catch the attacks from the pentest track. Adds the server. (Published.)
  • Phishing bridge: run a campaign and build the detection for it in one exercise. Uses both.
  • AI-augmented SOC: layer network inventory, dashboards, and AI triage on top of the detection stack. (Planned.)

Each track guide opens with a short foundation checklist that links back here, so you never lose your place in it.


Appendix A: Troubleshooting reference#

SymptomCauseFix
x86 VM won't boot, lands in a UEFI shellOld image expects BIOSUncheck QEMU → UEFI Boot
"Display output is not active" after choosing Graphical install on the Kali ARM64 installerUTM bug, per Kali's UTM guideAdd a Serial device and choose Install (see section 1)
"Display output is not active" on an old guestNo driver for UTM's default display cardSwitch the display card to plain VGA
Root filesystem much smaller than the diskLVM guided-install only claimed part of itlvextend -l +100%FREE then resize2fs
VMs cannot ping each otherMixed or wrong network modesPut every VM on the same Shared Network
A vulnerable box has internet you did not wantShared Network is NAT, not air-gappedPower targets off when idle
SSH to an old target is refusedModern OpenSSH drops legacy algorithmsAdd -oHostKeyAlgorithms=+ssh-rsa -oPubkeyAcceptedAlgorithms=+ssh-rsa
An ARM guest runs slowlyAccidentally created in Emulate modeRebuild it as Virtualize

Appendix B: VM quick reference#

VMRoleArch / UTM modeSuggested IPRAM
Kali LinuxAttackerARM64 / Virtualize192.168.64.24 GB
Ubuntu ServerSIEM hostARM64 / Virtualize192.168.64.36 GB
x86 target(s)Victimx86_64 / Emulate192.168.64.4–.60.5–1 GB

Appendix C: Screenshot checklist#

Capture these as you go; they are the evidence that the environment is built and the proof you point every track back to. Filenames follow fnd-<n> so a sorted folder reads in build order.

Screenshot IDWhat it showsStatus
fnd-0UTM overview with every lab VM listed
fnd-1Kali VM settings: ARM64 + Virtualize
fnd-1bKali terminal: uname -m → aarch64
fnd-2Ubuntu Server VM settings: ARM64 + Virtualize
fnd-2bUbuntu Server: df -h / after the LVM extend, uname -m
fnd-3x86 target VM settings: x86_64 + Emulate
fnd-3bx86 target reaching its boot / login banner
fnd-4UTM network settings: Shared Network on every VM
fnd-4bConnectivity: ip addr on Kali + a successful ping to the target
fnd-5qemu-img snapshot -c clean … creating a clean snapshot

Lab status#

The foundation environment is built and in daily use across the tracks in this portfolio. The pentest, detection, and phishing-bridge tracks run on it today, reusing the Ubuntu Server box set up here rather than standing up anything new. The AI-augmented SOC track is next and layers onto the same detection stack.

Get in touch today!

LAWAL logo

Engineering isn't just about writing code. It's about building systems people can depend on. LAWAL builds the product, hardens the systems behind it, and secures the people and process in between. Fast for users, hard on attackers.

Explore

  • Home
  • About
  • Tools & Tech
  • Projects
  • Security
  • Labs
  • Blog
  • FAQ

Socials

  • LinkedIn
  • GitHub
  • WhatsApp
Logic
L
Access
A
Workmanship
W
Assurance
A
Longevity
L