macOS 14+ · Apple Silicon · MIT licensed

Detonate samples.
Capture every frame.
Behind the hypervisor.

SecVF is a native macOS suite for malware analysis, network forensics, and incident response. Hardware-enforced VM isolation via Apple's Virtualization framework. An in-process L2/L3 software switch writes every frame straight into a tshark pipeline. Ephemeral macOS guests clone in sub-millisecond time via APFS copy-on-write. Open source. Auditable. Yours.

  • VZ hypervisor isolation
  • Sub-ms session clone
  • Wireshark display filters
  • Open source · audit it

What makes SecVF different

There are good VM apps, and there are good network analyzers. SecVF is a single native binary that's serious at both — and adds primitives the other tools don't have.

vs. UTM / VirtualBuddy

Generalist VM apps. They run guests well; they don't ship a packet pipeline, a router-VM workflow, or a DTrace/ESF-instrumented agent sandbox. SecVF treats malware-grade analysis as the first-class use case — not just "make a guest boot."

vs. VMware Fusion / Parallels

Closed-source, kernel-extension-based, Intel-DNA. You can't audit them, you can't extend them, and on Apple Silicon they run a translation shim. SecVF is pure Swift on the official Apple framework. No KEXT. No translation. You can read every line.

vs. Cuckoo Sandbox / Any.Run

Cuckoo is Linux-host, Windows-guest, Python 2-era. Any.Run is a SaaS — your sample leaves your machine. SecVF runs locally, offline, with native macOS guests for AI agents and any Linux/Windows guest for malware. Nothing leaves the host.

vs. REMnux / FLARE-VM

Those are guest distributions — bags of tools you boot inside a VM. Useful, but you still need a host platform around them. SecVF is the host platform: VM lifecycle, virtual switch, capture, telemetry, forensics-friendly storage. Bring REMnux as a guest on top.

Where SecVF stands alone: APFS-CoW session cloning (~0 ms), in-process L2/L3 software switch with no kext, vsock command channel for the AI agent sandbox, DTrace + Endpoint Security Framework telemetry, and SHA-256-pinned ISO/IPSW pipelines wired into the audit log.

Under the hood

Every layer is on the official Apple stack. No KEXTs. No System Extensions for the core. No kernel patches.

Hypervisor

Apple Virtualization framework

The same framework Apple uses for their own engineering builds. We use VZVirtualMachineConfiguration with explicit VZGenericPlatformConfiguration for Linux and VZMacPlatformConfiguration for macOS, VZEFIBootLoader for guests, and VZMacOSBootLoader for restored macOS guests.

  • VZVirtioNetworkDeviceConfiguration + custom VZBridgedNetworkDeviceAttachment for the switch
  • VZVirtioFileSystemDeviceConfiguration for opt-in workspace shares (off by default)
  • VZVirtioSocketDeviceConfiguration for the AI sandbox vsock channel
  • VZLinuxRosettaUnifiedCacheDirectoryShare on Apple Silicon for x86_64 binaries inside Linux guests
Network

VirtualNetworkSwitch (Swift, in-process)

Pure Swift L2/L3 software switch implemented as a Combine-driven actor. No kernel extension, no vmnet, no priv helper. Every Ethernet frame on the bus is routed in user space, MAC-learned, and mirrored to the capture sink as it forwards.

// VirtualNetworkSwitch.swift
let switch = VirtualNetworkSwitch.shared
let port  = switch.attach(vm: kaliRouter)            // L2 port assignment
switch.macTable.learn(mac: …, port: port)            // standard switch
switch.frames.sink { frame in PacketCapture.feed(frame) }
  • MAC learning, broadcast/unicast forwarding, ARP debug
  • Per-port byte/frame counters (visible in Switch Stats window)
  • Frame tap as a PassthroughSubject<EthernetFrame, Never> — multiple subscribers, lossless backpressure
  • Optional inline drop policy for fault injection
Capture

tshark + native protocol decode

SecVF spawns tshark headless against a FIFO populated by the switch tap. Output is parsed live as -T ek JSON; the UI presents Wireshark-style display filters straight from the source language.

  • Display filter: tcp.port == 443 && ip.addr == 10.0.100.5 — real Wireshark grammar
  • Per-protocol stats: TCP/UDP/DNS/ARP/ICMP/HTTP/TLS-ClientHello breakdown
  • PCAP export — uncompressed pcapng, importable into Wireshark/Zeek/Suricata
  • Hex view of every frame, side-by-side with decoded layers
AI Sandbox

Ephemeral macOS guests with vsock IPC

A canonical macOS guest is provisioned once. Each session spawns by APFS-cloning the base bundle (cheap copy-on-write — disk doesn't grow until the session writes). Boot, run a command over VZVirtioSocketDevice:2222, destroy.

let session = try await AISandboxVMSession.cloneBase()  // ~0 ms via APFS CoW
try await session.boot()
let result = try await session.run("clang --version")    // vsock 2222 RPC
try await session.destroy()                              // bundle wiped
  • Non-admin agent user inside guest — workspace-only write access
  • VirtioFS share scoped to one directory; everything else read-only
  • DTrace probes + Endpoint Security Framework telemetry from the host
  • Each session is a fresh hardware boundary, not a fresh container
Telemetry

VMSecurityMonitor + audit log

A @MainActor observer that watches filesystem deltas, process events, and resource pressure for each running VM. Events are typed and severity-graded; everything lands in ~/.avf/logs/security-YYYY-MM-DD.log.

  • Severity ladder: INFO → WARNING → CRITICAL → EMERGENCY
  • FSEvents stream for the bundle directory — disk-image growth, NVRAM mutation, side-channel writes
  • SecVFError typed enum with LocalizedError recovery suggestions, mirrored into error-audit.log
  • Tamper-resistant JSONL — append-only, easy to ship to a SIEM
Provisioning

Pinned ISO & IPSW pipelines

Every distro download is verified against a SHA-256 pulled from the upstream's signed checksum file. macOS IPSWs only come from *.cdn-apple.com over TLS 1.2+, with an explicit hostname allowlist. Anything else is rejected before a single byte hits disk.

  • 8 Linux distros pre-wired (Kali, Ubuntu, Debian, Fedora, Arch, Rocky, openSUSE, NixOS)
  • Versions discovered live from official mirrors — no stale lists baked in
  • Cache at ~/.avf/ISOCache/, dedup by SHA-256, audit-logged
  • Mismatch = file deleted + CRITICAL event raised

The analysis fabric

Four network modes per VM. Pick the right one and the malware never leaves the lab.

Mode: NAT

Default for dev work. Apple's framework provides DHCP and outbound NAT. Guest is invisible to the LAN. Cheap, works without configuration.

Mode: Virtual Switch

Air-gapped lab. Guests on the same software switch, no uplink. Useful for testing inter-VM behaviour with zero internet exposure.

Mode: Router VM

Kali Linux gateway. Static 10.0.100.1/24, iptables NAT, DHCP, tcpdump/tshark/nmap pre-installed. Helper commands: secvf-status, secvf-monitor, secvf-capture. Every byte traverses an instrumented gateway.

Mode: FakeNet

Router VM with all DNS sinkholed and HTTP/HTTPS/FTP/SMTP/IRC responders running. Malware contacts its C2 — and gets plausible-looking responses from the router. Full behavioural capture without phoning home.

Numbers that matter

Measured on M2 Pro, 32 GB. Your guest distro and capture profile will move these around.

~0 ms AI sandbox session clone APFS copy-on-write — disk doesn't grow until the session writes
< 8 s Linux guest cold boot Ubuntu 24.04, 4 GB RAM, NVMe-backed disk image
~1.2 Gbps Switch throughput VM-to-VM via the Swift L2 switch, single core, no kext
~110k pps tshark capture sustained JSON-EK output, no drop, on a single capture queue

Threat model

Be explicit about what we defend against, and what we don't.

Defended against

  • Userland escape from guest — guest userland never sees host filesystem; no shared folders by default.
  • Kernel exploits in guest — kernel boundary is the hypervisor, not a host kernel call. Escape requires hypervisor exploit.
  • Network exfiltration — virtual switch / router VM modes have no uplink without explicit config; FakeNet sinkholes the rest.
  • Tampered ISOs / IPSWs — SHA-256 verification mandatory; allowlist of source hostnames; mismatches deleted before mount.
  • Long-tail forensic loss — append-only audit log, severity-graded, kept under ~/.avf/logs/.

Not defended against

  • Apple Virtualization framework 0-days — the trust boundary. If it falls, so does the host.
  • Hardware side-channels — no defence against speculative execution leaks across guests, beyond what Apple Silicon mitigations provide.
  • Insider threats with admin on the host — anyone with root on your Mac can read VM disks, attach a debugger, etc.
  • Compromised dependencies — Swift Package Manager doesn't enforce SBOM. Audit your toolchain on each release.
  • Targeted UI deception (visual social engineering) — guest-controlled display can render anything. Don't trust dialogs from inside a hostile guest.

Read the full Security model for assumption-by-assumption detail.

Get SecVF

SecVF is in active development. Downloads aren't available yet — these are the three distribution paths planned for the first public release. Star the repo or watch releases to be notified.

Coming soon · Recommended

Direct download

Free · MIT · Developer ID notarized

  • Full feature parity — tshark shell-out, helper scripts, router VM tools
  • VM bundles in ~/.avf/
  • SHA-256 published per release — verify before opening
  • No telemetry, no phone-home
Coming soon .dmg · Apple Silicon · MIT

Will publish at github.com/DaxxSec/SecVF/releases once the first stable build is ready. Subscribe to the repo's releases to get notified.

Coming soon · For analysts

SIEM Edition

Free · MIT · with detection stack

  • Everything in the Direct download, plus:
  • Bundled siem/ directory — Loki + Promtail + Grafana + Suricata + YARA
  • Pre-built dashboards, Sigma-derived alert rules
  • One-click stack start from Settings
  • Requires a container runtime (OrbStack recommended)
Coming soon SIEM Edition · GitHub

SIEM Edition config preview is browsable in the repo today (siem/). See the SIEM wiki for what it does and the Containment Breakout guide for what to do when alerts fire.

Coming soon · Support the project

Mac App Store

$6.99 · sandboxed build

  • One-click install, automatic updates
  • Sandbox-compliant — minor adjustments noted in the wiki
  • SIEM stack not bundled (Apple sandbox limits)
  • Funds development of the open-source build
  • App Store payment, refunds, family sharing
Coming soon App Store submission planned

Same MIT-licensed code base, packaged for sandbox compliance. Pricing is a donation tier — buy if you want auto-updates and want to fund the project.

Requirements

macOS
14.0 Sonoma or later (Apple Virtualization framework features)
Architecture
Apple Silicon (M1+) for macOS guests · Apple Silicon or Intel for Linux/Windows guests
RAM
16 GB minimum; 32 GB+ for parallel guests + capture pipeline
Disk
20 GB free for the app + bundles. APFS recommended (mandatory for AI sandbox CoW cloning)
Optional
tshark for live packet capture: brew install wireshark
Optional
Xcode 15+ for source builds and contributing

Want to follow along?

SecVF is in active development. The code is open, the docs are live, and the first release is coming. Star the repo to be there when it ships.