Files
runaway/runaway-standalone.sh
T
2026-11-09 10:13:51 +08:00

3490 lines
102 KiB
Bash
Executable File

#!/bin/bash
set -euo pipefail
VERSION="2.0.0"
STANDALONE_BUILD=true
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
SCRIPT_PATH="$SCRIPT_DIR/$(basename "$0")"
RED='\033[1;31m'
GRN='\033[1;32m'
BLU='\033[1;34m'
YEL='\033[1;33m'
CYAN='\033[1;36m'
MAG='\033[1;35m'
NC='\033[0m'
LOG_FILE=""
VERBOSE=false
DRY_RUN=false
log() {
local level="$1"
local msg="$2"
local color=""
local label=""
case "$level" in
ERROR) color="$RED"; label="ERR" ;;
WARN) color="$YEL"; label="WRN" ;;
OK) color="$GRN"; label=" OK" ;;
INFO) color="$BLU"; label="INF" ;;
STEP) color="$CYAN"; label="STP" ;;
DEBUG) color="$MAG"; label="DBG" ;;
*) color="$NC"; label="LOG" ;;
esac
if [ "$level" = "DEBUG" ] && [ "$VERBOSE" = false ]; then
return
fi
local ts
ts=$(date '+%H:%M:%S')
echo -e "${color}[${label}]${NC} ${msg}" >&2
if [ -n "$LOG_FILE" ]; then
echo "[${ts}] [${label}] ${msg}" >> "$LOG_FILE" 2>/dev/null || true
fi
}
error_exit() {
log "ERROR" "$1"
exit 1
}
warn() {
log "WARN" "$1"
}
success() {
log "OK" "$1"
}
info() {
log "INFO" "$1"
}
step() {
log "STEP" "$1"
}
debug() {
log "DEBUG" "$1"
}
header() {
local title="$1"
local len="${#title}"
local line
line=$(printf '%*s' "$((len + 4))" '')
line="${line// /═}"
echo ""
echo -e "${CYAN}╔${line}╗${NC}"
echo -e "${CYAN}║ ${title} ║${NC}"
echo -e "${CYAN}╚${line}╝${NC}"
echo ""
}
begin() {
local label="$1"
echo -ne "${CYAN} ${label} ... ${NC}"
}
spinner() {
local pid=$1
local msg="${2:-Working}"
local spin='-\|/'
local i=0
while kill -0 "$pid" 2>/dev/null; do
i=$(( (i+1) % 4 ))
echo -ne "\r${CYAN} ${msg} ... ${spin:$i:1}${NC}"
sleep 0.2
done
echo -ne "\r${CYAN} ${msg} ... ${NC}"
}
end_ok() {
echo -e "${GRN}✓${NC}"
}
end_fail() {
echo -e "${RED}✗${NC}"
}
prompt_default() {
local var_name="$1"
local prompt_text="$2"
local default="$3"
local value
read -r -p "${CYAN}${prompt_text}${NC} (default '${default}'): " value
value="${value:=$default}"
eval "$var_name=\"$value\""
}
confirm() {
local prompt="$1"
local response
read -r -p "${prompt} (y/N): " response
[[ "$response" =~ ^[Yy]$ ]]
}
CONFIG_FILE="$HOME/.runaway.conf"
load_config() {
[ -f "$CONFIG_FILE" ] || return 0
local key value
while IFS='=' read -r key value || [ -n "$key" ]; do
key="${key// /}"
[ -z "$key" ] && continue
case "$key" in
WEBHOOK) DISCORD_WEBHOOK="$value" ;;
LOG_LEVEL) [ "$value" = "verbose" ] && VERBOSE=true ;;
LOG_FILE) LOG_FILE="$value" ;;
esac
done < "$CONFIG_FILE"
}
_rewrite_config() {
local key="$1"
local value="$2"
local tmp
[ -f "$CONFIG_FILE" ] || touch "$CONFIG_FILE"
tmp=$(mktemp "${CONFIG_FILE}.XXXXXX") || return 1
if ! RUNAWAY_CONFIG_KEY="$key" RUNAWAY_CONFIG_VALUE="$value" \
RUNAWAY_CONFIG_OPERATION="${3:-set}" awk '
BEGIN { key=ENVIRON["RUNAWAY_CONFIG_KEY"]; value=ENVIRON["RUNAWAY_CONFIG_VALUE"];
operation=ENVIRON["RUNAWAY_CONFIG_OPERATION"] }
index($0, key "=")==1 { if (!found++ && operation=="set") print key "=" value; next }
{ print }
END { if (!found && operation=="set") print key "=" value }
' "$CONFIG_FILE" > "$tmp"; then
rm -f "$tmp"
return 1
fi
mv "$tmp" "$CONFIG_FILE"
}
save_config() {
local key="$1" value="$2"
_rewrite_config "$key" "$value" || return 1
success "Saved $key to $CONFIG_FILE"
}
cmd_config() {
header "Configuration"
case "${2:-show}" in
show)
if [ ! -f "$CONFIG_FILE" ]; then
info "No config file at $CONFIG_FILE"
return 0
fi
step "Current settings ($CONFIG_FILE)"
cat "$CONFIG_FILE" | sed 's/^/ /'
;;
set)
local key="${3:-}"
local value="${4:-}"
[ -z "$key" ] || [ -z "$value" ] && {
info "Usage: ./runaway config set KEY VALUE"
info "Keys: WEBHOOK, LOG_LEVEL (verbose), LOG_FILE"
return 1
}
save_config "$key" "$value"
;;
unset)
local key="${3:-}"
[ -z "$key" ] && { info "Usage: ./runaway config unset KEY"; return 1; }
if [ -f "$CONFIG_FILE" ]; then
_rewrite_config "$key" "" unset || return 1
success "Removed $key from config"
fi
;;
*)
info "Usage: ./runaway config {show|set KEY VALUE|unset KEY}"
;;
esac
}
is_recovery() {
[ -d "/System/Installation" ] && return 0
local vol
vol=$(diskutil info / 2>/dev/null | awk -F': *' '/Volume Name/{print $2}' | xargs)
case "$vol" in
"Recovery"*|"macOS Base"*|"macOS Installer"*) return 0 ;;
esac
return 1
}
is_root() {
[[ $EUID -eq 0 ]]
}
resolve_data_volume() {
step "Locating Data volume by APFS role..."
local id mount_pt
id=$(diskutil apfs list 2>/dev/null \
| awk '/\(Data\)/ && match($0, /disk[0-9]+s[0-9]+/) {print substr($0, RSTART, RLENGTH); exit}')
if [ -z "$id" ] || ! diskutil info "/dev/$id" >/dev/null 2>&1; then
info "APFS role detection failed — trying name-based..."
id=$(diskutil list 2>/dev/null \
| awk '/[[:space:]]Data[[:space:]]/{for(i=1;i<=NF;i++) if($i ~ /^disk[0-9]+s[0-9]+$/) v=$i} END{print v}')
fi
if [ -z "$id" ] || ! diskutil info "/dev/$id" >/dev/null 2>&1; then
warn "Auto-detection failed. Available disks:"
diskutil list >&2
echo "" >&2
[ -t 0 ] || error_exit "Cannot select a Data volume without a terminal."
read -r -p "Enter Data volume identifier (e.g. disk3s1): " id </dev/tty
id="${id#/dev/}"
fi
[ -n "$id" ] || error_exit "No Data volume identifier provided."
local data_dev="/dev/$id"
diskutil info "$data_dev" >/dev/null 2>&1 || error_exit "Not a valid disk: $data_dev"
info "Data volume device: $data_dev"
_mount_point() {
diskutil info "$data_dev" 2>/dev/null \
| awk -F': *' '/Mount Point/{print $2}' | sed 's/[[:space:]]*$//'
}
mount_pt=$(_mount_point)
if [ -z "$mount_pt" ] || [ ! -d "$mount_pt" ]; then
info "Not mounted — mounting..."
diskutil mount "$data_dev" >&2 || true
mount_pt=$(_mount_point)
fi
if [ -z "$mount_pt" ] || [ ! -d "$mount_pt" ]; then
warn "FileVault-locked — need to unlock."
echo -e "${YEL}Enter password of a user on this Mac (or FileVault recovery key):${NC}" >&2
diskutil apfs unlockVolume "$data_dev" >&2 \
|| error_exit "Failed to unlock. Re-run with valid credentials."
mount_pt=$(_mount_point)
fi
[ -d "$mount_pt" ] || error_exit "Mount point not found after mount/unlock."
[ -d "$mount_pt/private/var/db/dslocal/nodes/Default" ] \
|| error_exit "Not a macOS Data volume (no dslocal node at $mount_pt)."
success "Data volume: $mount_pt"
echo "$mount_pt"
}
detect_system_volume() {
local data_mount="$1"
local vol
for vol in /Volumes/*; do
if [ -d "$vol/System" ] && [ "$vol" != "$data_mount" ]; then
basename "$vol"
return 0
fi
done
echo ""
}
resolve_target_volumes() {
local base_name data_name
read -r -p "Enter target system volume name (default 'Macintosh HD'): " base_name
base_name="${base_name:=Macintosh HD}"
read -r -p "Enter target data volume name (default 'Macintosh HD - Data'): " data_name
data_name="${data_name:=Macintosh HD - Data}"
local sys_path="/Volumes/$base_name"
local data_path="/Volumes/$data_name"
[ -d "$sys_path" ] || error_exit "System volume not found: $sys_path"
[ -d "$data_path" ] || error_exit "Data volume not found: $data_path"
echo "$sys_path|$data_path"
}
validate_username() {
local u="$1"
[ -z "$u" ] && { echo "Username cannot be empty" >&2; return 1; }
[ ${#u} -gt 31 ] && { echo "Username too long (max 31 chars)" >&2; return 1; }
[[ "$u" =~ ^[a-zA-Z0-9_-]+$ ]] \
|| { echo "Use only letters, numbers, underscore, hyphen" >&2; return 1; }
[[ "$u" =~ ^[a-zA-Z_] ]] \
|| { echo "Must start with a letter or underscore" >&2; return 1; }
return 0
}
validate_password() {
[ -z "$1" ] && { echo "Password cannot be empty" >&2; return 1; }
[ ${#1} -lt 4 ] && { echo "Minimum 4 characters" >&2; return 1; }
return 0
}
prompt_username() {
local var_name="$1"
local value
while true; do
read -r -p "Username (default 'Apple'): " value
value="${value:=Apple}"
if msg=$(validate_username "$value"); then
eval "$var_name=\"$value\""
return 0
else
warn "$msg"
fi
done
}
prompt_password() {
local var_name="$1"
local value
while true; do
read -r -p "Password (default '1234'): " value
value="${value:=1234}"
if msg=$(validate_password "$value"); then
eval "$var_name=\"$value\""
return 0
else
warn "$msg"
fi
done
}
dscl_node() {
local data_mount="$1"
echo "$data_mount/private/var/db/dslocal/nodes/Default"
}
check_user_exists() {
local node="$1"
local username="$2"
dscl -f "$node" localhost -read "/Local/Default/Users/$username" >/dev/null 2>&1
}
find_available_uid() {
local node="$1"
local uid=501
while [ $uid -lt 600 ]; do
dscl -f "$node" localhost -search /Local/Default/Users UniqueID $uid 2>/dev/null \
| grep -q "UniqueID" || { echo $uid; return 0; }
uid=$((uid + 1))
done
echo 501
}
delete_user() {
local node="$1"
local data_mount="$2"
local username="$3"
dscl -f "$node" localhost -delete "/Local/Default/Users/$username" 2>/dev/null || true
rm -rf "$data_mount/Users/$username" 2>/dev/null || true
}
create_admin_user() {
local node="$1"
local data_mount="$2"
local username="$3"
local realname="$4"
local password="$5"
local uid="$6"
local user_home="$data_mount/Users/$username"
if check_user_exists "$node" "$username"; then
error_exit "User '$username' already exists; choose a new username."
fi
if [ -e "$user_home" ] || [ -L "$user_home" ]; then
error_exit "Home already exists: $user_home; choose a new username."
fi
info "Creating admin account: $username"
dscl -f "$node" localhost -create "/Local/Default/Users/$username" 2>/dev/null \
|| error_exit "Failed to create user"
dscl -f "$node" localhost -create "/Local/Default/Users/$username" UserShell "/bin/zsh" 2>/dev/null
dscl -f "$node" localhost -create "/Local/Default/Users/$username" RealName "$realname" 2>/dev/null
dscl -f "$node" localhost -create "/Local/Default/Users/$username" UniqueID "$uid" 2>/dev/null
dscl -f "$node" localhost -create "/Local/Default/Users/$username" PrimaryGroupID "20" 2>/dev/null
dscl -f "$node" localhost -create "/Local/Default/Users/$username" NFSHomeDirectory "/Users/$username" 2>/dev/null
dscl -f "$node" localhost -passwd "/Local/Default/Users/$username" "$password" 2>/dev/null \
|| error_exit "Failed to set password"
dscl -f "$node" localhost -append "/Local/Default/Groups/admin" GroupMembership "$username" 2>/dev/null \
|| error_exit "Failed to grant admin"
mkdir -p "$user_home" || error_exit "Failed to create home directory"
chown "$uid:20" "$user_home" || error_exit "Failed to assign home ownership"
success "Admin '$username' created (UID $uid)"
}
hide_user() {
local node="$1"
local data_mount="$2"
local username="$3"
info "Hiding user account: $username"
check_user_exists "$node" "$username" || error_exit "Could not find user '$username'"
dscl -f "$node" localhost -create "/Local/Default/Users/$username" IsHidden "1" 2>/dev/null
chflags hidden "$data_mount/Users/$username"
success "User '$username' hidden"
}
add_to_filevault() {
local username="$1"
if command -v fdesetup &>/dev/null \
&& fdesetup supportsauthorizedusers 2>/dev/null | grep -q true; then
fdesetup add -usertoadd "$username" 2>/dev/null || true
fi
}
PB="${PB:-/usr/libexec/PlistBuddy}"
_restore_rosetta_hosts() {
local hosts="$1" tmp_hosts
tmp_hosts=$(mktemp "${hosts}.XXXXXX") || return 1
if ! cp -p "$hosts" "$tmp_hosts" || ! awk '
$0=="# Added by runaway — DEP enrollment block" { owned=1; print; next }
owned && /^(0[.]0[.]0[.]0|::)[[:space:]]+configuration[.]apple[.]com[[:space:]]*$/ { next }
owned && $0 !~ /^(0[.]0[.]0[.]0|::)[[:space:]]+[[:alnum:]_.-]+[[:space:]]*$/ { owned=0 }
{ print }
' "$hosts" > "$tmp_hosts"; then
rm -f "$tmp_hosts"
return 1
fi
if cmp -s "$hosts" "$tmp_hosts"; then
rm -f "$tmp_hosts"
return 0
fi
if [ ! -e "$hosts.runaway-rosetta.bak" ]; then
cp -p "$hosts" "$hosts.runaway-rosetta.bak" || { rm -f "$tmp_hosts"; return 1; }
fi
mv "$tmp_hosts" "$hosts" || { rm -f "$tmp_hosts"; return 1; }
info "Removed old Runaway Rosetta blocks; backup: $hosts.runaway-rosetta.bak"
}
suppress_enrollment() {
local data_mount="$1"
if [ "$DRY_RUN" = true ]; then
info "[DRY RUN] Would suppress MDM enrollment on $data_mount"
info "[DRY RUN] - Clear DEP markers in ConfigurationProfiles/Settings"
info "[DRY RUN] - Block 13+ Apple MDM domains in /etc/hosts"
info "[DRY RUN] - Disable 4 enrollment daemons in launchd disabled.plist"
info "[DRY RUN] - Clean MDM artifacts from /Users/*/Library"
return 0
fi
local hosts="$data_mount/private/etc/hosts"
local cfg="$data_mount/private/var/db/ConfigurationProfiles/Settings"
local ldp="$data_mount/private/var/db/com.apple.xpc.launchd/disabled.plist"
local setupdone="$data_mount/private/var/db/.AppleSetupDone"
step "Reading DEP activation record..."
local mdm_host="" org=""
if [ -f "$cfg/.cloudConfigRecordFound" ]; then
mdm_host=$(plutil -convert xml1 -o - "$cfg/.cloudConfigRecordFound" 2>/dev/null \
| grep -ioE 'https?://[a-z0-9._-]+' | sed -E 's#https?://##' \
| sort -u | grep -viE '(^|\.)apple\.com$' | head -1 || true)
org=$(plutil -convert xml1 -o - "$cfg/.cloudConfigRecordFound" 2>/dev/null \
| grep -iA1 OrganizationName | tail -1 | sed -E 's/.*<string>(.*)<\/string>.*/\1/' || true)
[ -n "$org" ] && info "Device assigned in ABM to: $org"
[ -n "$mdm_host" ] && info "Org MDM host: $mdm_host"
else
info "No DEP activation record present."
fi
step "Blocking enrollment domains (Data volume hosts)..."
[ -f "$hosts" ] || { mkdir -p "$(dirname "$hosts")"; touch "$hosts"; }
_restore_rosetta_hosts "$hosts" || error_exit "Could not repair old Rosetta hosts blocks."
grep -q "Added by runaway" "$hosts" 2>/dev/null || {
echo "" >>"$hosts"
echo "# Added by runaway — DEP enrollment block" >>"$hosts"
}
local domains=(
iprofiles.apple.com
deviceenrollment.apple.com
mdmenrollment.apple.com
acmdm.apple.com
axm-adm-mdm.apple.com
albert.apple.com
gdmf.apple.com
ax.init-content.apple.com
init-content.apple.com
xp.apple.com
gs.apple.com
tb.apple.com
vpp.itunes.apple.com
)
[ -n "$mdm_host" ] && domains+=("$mdm_host")
local d
for d in "${domains[@]}"; do
grep -qiE "[[:space:]]$d(\$|[[:space:]])" "$hosts" 2>/dev/null \
&& { info "$d already blocked"; continue; }
printf '0.0.0.0 %s\n:: %s\n' "$d" "$d" >>"$hosts"
success "blocked $d"
done
step "Resetting DEP markers..."
mkdir -p "$cfg"
rm -f "$cfg/.cloudConfigHasActivationRecord" \
"$cfg/.cloudConfigRecordFound" \
"$cfg/.cloudConfigTimerCheck" \
"$cfg/.cloudConfigProfileInstalled" \
"$cfg/com.apple.mdm.depnag.plist" \
"$cfg/com.apple.mdm.prelogin.plist" 2>/dev/null
touch "$cfg/.cloudConfigRecordNotFound"
success "Cached record cleared; bypass markers set"
step "Cleaning user-level MDM artifacts..."
local home
for home in "$data_mount/Users/"*/; do
[ -d "$home/Library" ] || continue
local user
user=$(basename "$home")
info "Cleaning: $user"
rm -rf "$home/Library/Preferences/com.apple.mdm"* 2>/dev/null || true
rm -rf "$home/Library/Preferences/com.apple.ManagedClient"* 2>/dev/null || true
rm -rf "$home/Library/Application Support/com.apple.ManagedClient"* 2>/dev/null || true
rm -rf "$home/Library/LaunchAgents/com.apple.mdm"* 2>/dev/null || true
for agent in "$home/Library/LaunchAgents/"*; do
[ -f "$agent" ] || continue
if grep -qi mdm "$agent" 2>/dev/null || grep -qi enrollment "$agent" 2>/dev/null; then
rm -f "$agent"
info " removed LaunchAgent: $(basename "$agent")"
fi
done
done
success "User-level MDM artifacts removed"
step "Disabling enrollment daemons..."
mkdir -p "$(dirname "$ldp")"
[ -f "$ldp" ] || printf '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict/></plist>\n' >"$ldp"
for label in \
com.apple.ManagedClient.enroll \
com.apple.ManagedClient.cloudConfiguration \
com.apple.mdmclient.daemon.runatboot \
com.apple.activationd; do
$PB -c "Add :$label bool true" "$ldp" 2>/dev/null \
|| $PB -c "Set :$label true" "$ldp" 2>/dev/null
info "disabled $label"
done
success "Enrollment daemons disabled (4 overrides)"
touch "$setupdone" 2>/dev/null || true
}
suppress_only_mode() {
local data_mount="$1"
echo ""
info "Suppress-only mode: no user will be created."
suppress_enrollment "$data_mount"
echo ""
echo -e "${GRN}============================================${NC}"
echo -e "${GRN} Enrollment Suppressed ${NC}"
echo -e "${GRN}============================================${NC}"
echo ""
echo -e "${CYAN}Reboot to apply.${NC}"
echo -e "${YEL}After a macOS update: re-run.${NC}"
echo -e "${YEL}Never run 'profiles renew' or Erase All Content & Settings.${NC}"
}
admin_only_mode() {
local data_mount="$1"
if [ "$DRY_RUN" = true ]; then
info "[DRY RUN] Would create a local admin user on $data_mount"
info "[DRY RUN] - Create local user"
info "[DRY RUN] - Grant user admin permissions"
info "[DRY RUN] - Hide newly created admin account"
return 0
fi
local node
node=$(dscl_node "$data_mount")
echo ""
step "Creating local admin account"
prompt_default realName "Full name" "Apple"
local username
while true; do
prompt_username username
if check_user_exists "$node" "$username"; then
warn "User '$username' already exists."
if confirm "Delete and recreate?"; then
delete_user "$node" "$data_mount" "$username"
break
else
echo -e "${YEL}Choose a different username.${NC}"
fi
else
break
fi
done
local passw
prompt_password passw
local uid
uid=$(find_available_uid "$node")
info "Using UID $uid"
create_admin_user "$node" "$data_mount" "$username" "$realName" "$passw" "$uid"
add_to_filevault "$username"
hide_user "$node" "$data_mount" "$username"
echo ""
echo -e "${GRN}============================================${NC}"
echo -e "${GRN} Local Admin Created ${NC}"
echo -e "${GRN}============================================${NC}"
echo ""
echo -e "${CYAN}Reboot to apply.${NC}"
}
full_bypass_mode() {
local data_mount="$1"
if [ "$DRY_RUN" = true ]; then
info "[DRY RUN] Would perform full MDM bypass on $data_mount"
info "[DRY RUN] - Create admin user"
info "[DRY RUN] - Skip Setup Assistant (.AppleSetupDone)"
info "[DRY RUN] - Then run suppress_enrollment"
return 0
fi
local node
node=$(dscl_node "$data_mount")
echo ""
step "Creating temporary admin account"
local realName
prompt_default realName "Full name" "Apple"
local username
while true; do
prompt_username username
if check_user_exists "$node" "$username"; then
warn "User '$username' already exists."
if confirm "Delete and recreate?"; then
delete_user "$node" "$data_mount" "$username"
break
else
echo -e "${YEL}Choose a different username.${NC}"
fi
else
break
fi
done
local passw
prompt_password passw
local uid
uid=$(find_available_uid "$node")
info "Using UID $uid"
create_admin_user "$node" "$data_mount" "$username" "$realName" "$passw" "$uid"
touch "$data_mount/private/var/db/.AppleSetupDone"
success "Setup Assistant will be skipped"
add_to_filevault "$username"
suppress_enrollment "$data_mount"
echo ""
echo -e "${GRN}============================================${NC}"
echo -e "${GRN} MDM Bypass Complete ${NC}"
echo -e "${GRN}============================================${NC}"
echo ""
echo -e "${CYAN}Login:${NC} ${YEL}$username${NC} / ${YEL}$passw${NC}"
echo -e "${YEL}After macOS update: re-run. Never 'profiles renew'.${NC}"
}
BACKUP_DIR="$(dirname "$(dirname "$0")")/.runaway-backup"
check_disk_space() {
local data_mount="$1"
local needed_kb=10240
local available_kb
available_kb=$(df -k "$data_mount" 2>/dev/null | tail -1 | awk '{print $4}')
if [ -n "$available_kb" ] && [ "$available_kb" -lt "$needed_kb" ]; then
warn "Low disk space: $(echo "$available_kb" | awk '{printf "%.0f MB", $1/1024}') available"
echo -n "Continue anyway? [y/N] "
read -r answer
[ "$answer" != "y" ] && [ "$answer" != "Y" ] && error_exit "Aborted by user"
fi
}
backup_state() {
local data_mount="$1"
mkdir -p "$BACKUP_DIR"
check_disk_space "$data_mount"
step "Saving backup to $BACKUP_DIR"
if [ -f "$data_mount/private/etc/hosts" ]; then
cp "$data_mount/private/etc/hosts" "$BACKUP_DIR/hosts.backup"
success "hosts saved"
fi
local cfg_src="$data_mount/private/var/db/ConfigurationProfiles/Settings"
if [ -d "$cfg_src" ]; then
mkdir -p "$BACKUP_DIR/ConfigurationProfiles"
cp -r "$cfg_src/"* "$BACKUP_DIR/ConfigurationProfiles/" 2>/dev/null || true
success "config profiles saved"
fi
local ldp_src="$data_mount/private/var/db/com.apple.xpc.launchd/disabled.plist"
if [ -f "$ldp_src" ]; then
mkdir -p "$BACKUP_DIR/launchd"
cp "$ldp_src" "$BACKUP_DIR/launchd/disabled.plist.backup" 2>/dev/null || true
success "launchd override saved"
fi
date +%Y-%m-%d_%H-%M-%S >"$BACKUP_DIR/timestamp"
echo "$data_mount" >"$BACKUP_DIR/data_volume_path"
success "Backup complete: $(cat "$BACKUP_DIR/timestamp")"
}
restore_state() {
[ -f "$BACKUP_DIR/timestamp" ] || error_exit "No backup found at $BACKUP_DIR"
local data_mount
if [ -f "$BACKUP_DIR/data_volume_path" ]; then
data_mount=$(cat "$BACKUP_DIR/data_volume_path")
if [ ! -d "$data_mount/private/var" ]; then
warn "Saved path unavailable — re-detecting..."
data_mount=$(resolve_data_volume)
fi
else
data_mount=$(resolve_data_volume)
fi
step "Restoring from backup ($(cat "$BACKUP_DIR/timestamp"))"
echo -e "${YEL}Target: $data_mount${NC}"
if [ -f "$BACKUP_DIR/hosts.backup" ]; then
cp "$BACKUP_DIR/hosts.backup" "$data_mount/private/etc/hosts"
success "hosts restored"
fi
if [ -d "$BACKUP_DIR/ConfigurationProfiles" ]; then
local cfg="$data_mount/private/var/db/ConfigurationProfiles/Settings"
mkdir -p "$cfg"
cp -r "$BACKUP_DIR/ConfigurationProfiles/"* "$cfg/" 2>/dev/null || true
success "config profiles restored"
fi
if [ -f "$BACKUP_DIR/launchd/disabled.plist.backup" ]; then
local ldp="$data_mount/private/var/db/com.apple.xpc.launchd/disabled.plist"
mkdir -p "$(dirname "$ldp")"
cp "$BACKUP_DIR/launchd/disabled.plist.backup" "$ldp"
success "launchd override restored"
fi
sed -i '' '/# Added by runaway/d' "$data_mount/private/etc/hosts" 2>/dev/null || true
rm -f "$BACKUP_DIR/data_volume_path" "$BACKUP_DIR/timestamp"
success "Restore complete"
}
has_backup() {
[ -f "$BACKUP_DIR/timestamp" ]
}
check_mdm_status() {
local data_mount="$1"
local hosts="$data_mount/private/etc/hosts"
local cfg="$data_mount/private/var/db/ConfigurationProfiles/Settings"
local ldp="$data_mount/private/var/db/com.apple.xpc.launchd/disabled.plist"
header "MDM Status Report"
step "DEP markers ($cfg)"
if [ -d "$cfg" ]; then
for f in \
.cloudConfigHasActivationRecord \
.cloudConfigRecordFound \
.cloudConfigRecordNotFound \
.cloudConfigProfileInstalled \
.cloudConfigTimerCheck; do
if [ -f "$cfg/$f" ]; then
echo -e " ${GRN}$f${NC} — present"
else
echo -e " ${YEL}$f${NC} — absent"
fi
done
else
warn "Settings directory not found"
fi
echo ""
step "Blocked domains in hosts"
if [ -f "$hosts" ]; then
local matches
matches=$(grep -iE 'iprofiles|enrollment|mdm|acmdm|albert|gdmf|configuration|xp\.apple|gs\.apple|tb\.apple' "$hosts" 2>/dev/null)
if [ -n "$matches" ]; then
echo "$matches" | while IFS= read -r line; do
echo -e " ${GRN}$line${NC}"
done
else
echo -e " ${YEL}(none)${NC}"
fi
local count; count=$(echo "$matches" | grep -c . 2>/dev/null || true)
count="${count:-0}"
echo -e " ${CYAN}Total: $count of 13 expected domains blocked${NC}"
else
echo -e " ${YEL}(hosts not found)${NC}"
fi
echo ""
step "Enrollment daemon status"
if [ -f "$ldp" ]; then
/usr/libexec/PlistBuddy -c "Print" "$ldp" 2>/dev/null || echo -e " ${YEL}(empty/corrupt)${NC}"
else
echo -e " ${YEL}(no override)${NC}"
fi
echo ""
step "Profiles enrollment status"
if command -v profiles &>/dev/null; then
profiles status -type enrollment 2>/dev/null \
|| echo -e " ${YEL}Cannot check (expected in Recovery)${NC}"
else
echo -e " ${YEL}'profiles' not available${NC}"
fi
echo ""
step "Backup status"
if has_backup; then
echo -e " ${GRN}Backup exists:${NC} $(cat "$BACKUP_DIR/timestamp")"
else
echo -e " ${YEL}No backup${NC}"
fi
echo ""
if [ -f "$cfg/.cloudConfigRecordFound" ]; then
local org
org=$(plutil -convert xml1 -o - "$cfg/.cloudConfigRecordFound" 2>/dev/null \
| grep -iA1 OrganizationName | tail -1 | sed -E 's/.*<string>(.*)<\/string>.*/\1/')
[ -n "$org" ] && echo -e "${YEL}Active DEP record found — device assigned to: $org${NC}"
else
echo -e "${GRN}No active DEP record.${NC}"
fi
}
_mdm_agent_names() {
local agent
for agent in "$1/"*; do
[ -f "$agent" ] || continue
if printf '%s\n' "${agent##*/}" | grep -qiE 'mdm|enrollment|managed'; then
printf '%s\n' "${agent##*/}"
fi
done
}
deep_status() {
if [ "${1:-}" = "--json" ]; then
deep_status_json
return
fi
header "Deep MDM Audit"
step "Installed Configuration Profiles"
if command -v profiles &>/dev/null; then
local profile_count
profile_count=$(sudo profiles -C -output stdout-xml 2>/dev/null | grep -c "ProfileDisplayName" || true)
profile_count="${profile_count:-0}"
if [ "$profile_count" -gt 0 ]; then
warn "$profile_count profile(s) installed:"
sudo profiles -C -output stdout-xml 2>/dev/null | grep -A1 "ProfileDisplayName" | grep "<string>" | sed 's/.*<string>\(.*\)<\/string>.*/ - \1/'
else
info "No configuration profiles installed"
fi
else
warn "profiles command not available"
fi
echo ""
step "MDM Enrollment State"
if command -v profiles &>/dev/null; then
sudo profiles status -type enrollment 2>/dev/null || echo " Cannot determine"
fi
echo ""
step "MDM Identity Certificates (Keychain)"
if command -v security &>/dev/null; then
local mdm_certs
mdm_certs=$(sudo security find-identity -p basic 2>/dev/null | grep -ci "mdm\|MDM\|Apple.*Push" || true)
if [ "$mdm_certs" -gt 0 ]; then
warn "$mdm_certs MDM-related certificate(s) found"
sudo security find-identity -p basic 2>/dev/null | grep -i "mdm\|Apple.*Push"
else
info "No MDM certificates found in keychain"
fi
else
warn "security command not available"
fi
echo ""
step "MDM LaunchAgents (User)"
local found=0
for home in /Users/*/; do
[ -d "$home/Library/LaunchAgents" ] || continue
local user_agents
user_agents=$(_mdm_agent_names "$home/Library/LaunchAgents")
if [ -n "$user_agents" ]; then
echo -e " ${YEL}$(basename "$home"):${NC}"
while IFS= read -r agent; do printf ' %s\n' "$agent"; done <<< "$user_agents"
found=$((found + 1))
fi
done
[ "$found" -eq 0 ] && info "No MDM LaunchAgents found in any user"
echo ""
step "MDM LaunchDaemons (System)"
local sys_agents
sys_agents=$(_mdm_agent_names /Library/LaunchDaemons)
if [ -n "$sys_agents" ]; then
while IFS= read -r agent; do printf ' %s\n' "$agent"; done <<< "$sys_agents"
else
info "No MDM LaunchDaemons found"
fi
echo ""
step "Running MDM Processes"
local procs
procs=$(pgrep -il "mdm|managedclient|activation" 2>/dev/null || true)
if [ -n "$procs" ]; then
echo "$procs" | awk '{print " " $2 " (PID " $1 ")"}'
else
info "No MDM processes running"
fi
echo ""
step "MDM Agent Binaries"
for agent_bin in /usr/local/bin/jamf /usr/local/bin/jamfagent /opt/jamf/bin/jamf \
/usr/local/bin/intune /usr/local/bin/microsoft-intune \
/Applications/Jamf* /Applications/Microsoft\ Intune* /Applications/VMware\ Workspace*; do
if [ -e "$agent_bin" ]; then
warn "Agent binary found: $agent_bin"
fi
done
info "Scan complete"
echo ""
step "Firewall Status"
pf_status 2>/dev/null || info "pf firewall check skipped"
step "Overall Assessment"
local risk="LOW"
local cfg="/private/var/db/ConfigurationProfiles/Settings"
local installed
installed=$(sudo profiles -C -output stdout-xml 2>/dev/null | grep -c "ProfileDisplayName" || true)
installed="${installed:-0}"
[ "$installed" -gt 0 ] && risk="MEDIUM"
pgrep -i "mdm|managedclient" >/dev/null 2>&1 && risk="HIGH"
[ -f "$cfg/.cloudConfigRecordFound" ] && risk="CRITICAL"
case "$risk" in
LOW) echo -e " ${GRN}Risk: $risk — Device appears clean${NC}" ;;
MEDIUM) echo -e " ${YEL}Risk: $risk — Residual profiles detected${NC}" ;;
HIGH) echo -e " ${RED}Risk: $risk — MDM processes still running${NC}" ;;
CRITICAL) echo -e " ${RED}Risk: $risk — Active DEP record found${NC}" ;;
esac
}
deep_status_json() {
local json=""
json="${json}{\n"
json="${json} \"version\": \"$VERSION\",\n"
json="${json} \"timestamp\": \"$(date -u '+%Y-%m-%dT%H:%M:%SZ')\",\n"
local profile_count=0
if command -v profiles &>/dev/null; then
profile_count=$(sudo profiles -C -output stdout-xml 2>/dev/null | grep -c "ProfileDisplayName" || true)
profile_count="${profile_count:-0}"
fi
json="${json} \"profile_count\": $profile_count,\n"
local enroll_state="unknown"
if command -v profiles &>/dev/null; then
enroll_state=$(sudo profiles status -type enrollment 2>/dev/null | head -1 | xargs || echo "unknown")
fi
enroll_state="${enroll_state//\"/\\\"}"
json="${json} \"enrollment_state\": \"${enroll_state}\",\n"
local mdm_certs=0
if command -v security &>/dev/null; then
mdm_certs=$(sudo security find-identity -p basic 2>/dev/null | grep -ci "mdm\|MDM\|Apple.*Push" || true)
fi
json="${json} \"mdm_certificates\": $mdm_certs,\n"
local running_procs=0
running_procs=$(pgrep -il "mdm|managedclient|activation" 2>/dev/null | awk 'END {print NR}' || true)
json="${json} \"running_mdm_processes\": $running_procs,\n"
local risk="LOW"
[ "$profile_count" -gt 0 ] && risk="MEDIUM"
[ "$running_procs" -gt 0 ] && risk="HIGH"
[ -f "/private/var/db/ConfigurationProfiles/Settings/.cloudConfigRecordFound" ] && risk="CRITICAL"
json="${json} \"risk_score\": \"${risk}\"\n"
json="${json}}"
echo -e "$json"
}
_launchd_script_path() {
local script_path="${SCRIPT_PATH:-}"
if [ -z "$script_path" ]; then
script_path="$(cd "$(dirname "$0")" && pwd)/$(basename "$0")"
fi
printf '%s' "$script_path" | sed 's/&/\&amp;/g; s/</\&lt;/g; s/>/\&gt;/g'
}
heal_suppress() {
local data_mount="$1"
[ -z "$data_mount" ] && data_mount=""
step "Checking current MDM suppression state..."
local cfg="${data_mount}/private/var/db/ConfigurationProfiles/Settings"
local hosts="${data_mount}/private/etc/hosts"
local ldp="${data_mount}/private/var/db/com.apple.xpc.launchd/disabled.plist"
if [ "$DRY_RUN" != true ] && [ -f "$hosts" ]; then
_restore_rosetta_hosts "$hosts" || error_exit "Could not repair old Rosetta hosts blocks."
fi
local needs_heal=false
if [ -f "$cfg/.cloudConfigRecordFound" ]; then
warn "DEP activation record present"
needs_heal=true
else
info "DEP markers clean"
fi
if [ -f "$hosts" ]; then
if grep -q "iprofiles.apple.com" "$hosts" 2>/dev/null; then
info "Domain block active"
else
warn "Domain block missing"
needs_heal=true
fi
else
warn "Hosts file missing"
needs_heal=true
fi
if [ -f "$ldp" ]; then
local missing=0
for label in com.apple.ManagedClient.enroll com.apple.mdmclient.daemon.runatboot; do
$PB -c "Print :$label" "$ldp" 2>/dev/null | grep -q "true" || missing=$((missing + 1))
done
if [ "$missing" -gt 0 ]; then
warn "$missing enrollment daemon(s) not disabled"
needs_heal=true
else
info "Enrollment daemons disabled"
fi
else
warn "Launchd override missing"
needs_heal=true
fi
if [ "$needs_heal" = false ]; then
success "MDM suppression intact — no action needed"
return 0
fi
step "Re-applying MDM suppression..."
suppress_enrollment "$data_mount"
success "MDM suppression restored"
}
_persist_mount_root() {
local dm="$1"
if [ -z "$dm" ] || [ ! -d "$dm/Library" ]; then
echo ""
else
echo "$dm"
fi
}
install_persist_launchdaemon() {
local data_mount="$1"
local root
root="$(_persist_mount_root "$data_mount")"
local runaway_src
runaway_src=$(_launchd_script_path)
step "Installing LaunchDaemon for boot-time persistence..."
local plist_dir="${root}/Library/LaunchDaemons"
local plist_path="${plist_dir}/com.runaway.heal.plist"
mkdir -p "$plist_dir"
cat > "$plist_path" <<- PLIST
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.runaway.heal</string>
<key>ProgramArguments</key>
<array>
<string>/bin/bash</string>
<string>${runaway_src}</string>
<string>heal</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>StartInterval</key>
<integer>86400</integer>
<key>Nice</key>
<integer>1</integer>
<key>KeepAlive</key>
<false/>
<key>StandardOutPath</key>
<string>/var/log/runaway-heal.log</string>
<key>StandardErrorPath</key>
<string>/var/log/runaway-heal.err</string>
</dict>
</plist>
PLIST
chmod 644 "$plist_path"
success "LaunchDaemon written to $plist_path"
step "Loading LaunchDaemon..."
if command -v launchctl &>/dev/null; then
if launchctl load "$plist_path" 2>/dev/null; then
success "LaunchDaemon loaded (will run on next boot)"
else
info "LaunchDaemon will load on next boot"
fi
else
info "launchctl not available (expected in Recovery) — will load on next boot"
fi
}
remove_persist_launchdaemon() {
local data_mount="$1"
local root
root="$(_persist_mount_root "$data_mount")"
local plist_path="${root}/Library/LaunchDaemons/com.runaway.heal.plist"
if [ -f "$plist_path" ]; then
step "Removing Runaway LaunchDaemon..."
if command -v launchctl &>/dev/null; then
launchctl unload "$plist_path" 2>/dev/null || true
fi
rm -f "$plist_path"
success "LaunchDaemon removed"
else
info "No Runaway LaunchDaemon installed"
fi
}
FIREWALL_ANCHOR="com.runaway/mdm"
FIREWALL_CONF="/etc/pf.conf"
FIREWALL_ANCHOR_DIR="/etc/pf.anchors"
pf_backup_anchor() {
local root="$1"
local anchor_file="${root}${FIREWALL_ANCHOR_DIR}/${FIREWALL_ANCHOR}"
[ ! -f "$anchor_file" ] && return 0
local backup
backup="${anchor_file}.backup.$(date +%s)"
cp "$anchor_file" "$backup" && info "Backed up pf anchor: $backup"
}
pf_backup_conf() {
local root="$1"
local pf_conf="${root}${FIREWALL_CONF}"
[ ! -f "$pf_conf" ] && return 0
local backup
backup="${pf_conf}.backup.$(date +%s)"
cp "$pf_conf" "$backup" && info "Backed up pf.conf: $backup"
}
install_pf_mdm_block() {
local data_mount="$1"
local root=""
[ -n "$data_mount" ] && root="$data_mount"
step "Installing pf anchor for MDM IP block..."
pf_backup_conf "$root"
local anchor_dir="${root}${FIREWALL_ANCHOR_DIR}"
local anchor_file="${anchor_dir}/${FIREWALL_ANCHOR}"
pf_backup_anchor "$root"
mkdir -p "$anchor_dir"
cat > "$anchor_file" << 'ANCHOR'
# Runaway MDM block — Apple MDM infrastructure IP ranges
# These ranges host deviceenrollment.apple.com, mdmenrollment.apple.com, etc.
# Blocking at pf level is immune to DNS-over-HTTPS bypass.
block drop out proto {tcp,udp} to {17.0.0.0/8}
block drop out proto {tcp,udp} to {17.128.0.0/10}
ANCHOR
chmod 644 "$anchor_file"
success "Anchor written: $anchor_file"
local pf_conf="${root}${FIREWALL_CONF}"
local anchor_line="anchor \"${FIREWALL_ANCHOR}\""
local load_line="load anchor \"${FIREWALL_ANCHOR}\" from \"${anchor_file}\""
if [ -f "$pf_conf" ]; then
if grep -q "com.runaway" "$pf_conf" 2>/dev/null; then
info "pf.conf already has Runaway anchor"
else
printf '\n%s\n%s\n%s\n' "# Added by runaway — MDM block" "$anchor_line" "$load_line" >> "$pf_conf"
success "pf.conf updated"
fi
else
cat > "$pf_conf" <<- EOF
# pf.conf — restored by runaway
#
# Default macOS pf.conf
scrub-anchor "com.apple/*"
nat-anchor "com.apple/*"
rdr-anchor "com.apple/*"
dummynet-anchor "com.apple/*"
fwd-anchor "com.apple/*"
anchor "com.apple/*"
load anchor "com.apple" from "/etc/pf.anchors/com.apple"
# Added by runaway — MDM block
${anchor_line}
${load_line}
EOF
success "pf.conf created with Runaway anchor"
fi
step "Loading pf rules..."
if command -v pfctl &>/dev/null; then
if pfctl -e -f "$pf_conf" 2>/dev/null; then
success "pf enabled and rules loaded"
else
warn "pfctl failed — try: sudo pfctl -e -f $pf_conf"
fi
else
warn "pfctl not available"
fi
warn "This blocks ALL Apple services (iCloud, App Store, updates)."
warn "For selective blocking, use Little Snitch or LuLu instead."
}
remove_pf_mdm_block() {
local data_mount="$1"
local root=""
[ -n "$data_mount" ] && root="$data_mount"
step "Removing Runaway pf anchor..."
local anchor_file="${root}${FIREWALL_ANCHOR_DIR}/${FIREWALL_ANCHOR}"
if [ -f "$anchor_file" ]; then
pf_backup_anchor "$root"
rm -f "$anchor_file"
success "Anchor file removed"
fi
local pf_conf="${root}${FIREWALL_CONF}"
if [ -f "$pf_conf" ]; then
local tmp_conf
tmp_conf=$(mktemp "${pf_conf}.XXXXXX") || return 1
if ! cp -p "$pf_conf" "$tmp_conf" \
|| ! sed '/# Added by runaway/d; /com\.runaway/d' "$pf_conf" > "$tmp_conf" \
|| ! mv "$tmp_conf" "$pf_conf"; then
rm -f "$tmp_conf"
return 1
fi
success "pf.conf cleaned"
fi
step "Flushing pf anchor..."
if command -v pfctl &>/dev/null; then
pfctl -a "$FIREWALL_ANCHOR" -F all 2>/dev/null || true
success "pf anchor flushed"
else
warn "pfctl not available"
fi
}
pf_status() {
step "pf firewall status..."
if command -v pfctl &>/dev/null; then
pfctl -si 2>/dev/null | grep -E "Status|Enabled" || echo " pf not enabled"
echo ""
if pfctl -a "$FIREWALL_ANCHOR" -s rules 2>/dev/null; then
info "Runaway MDM anchor rules:"
else
info "No Runaway MDM anchor loaded"
fi
else
warn "pfctl not available"
fi
}
harden_live_os() {
step "Killing running MDM processes..."
for p in ManagedClient mdmclient activationd; do
if pkill -f "$p" 2>/dev/null; then
success "Killed $p"
else
info "$p not running"
fi
done
step "Removing residual MDM profiles..."
if command -v profiles &>/dev/null; then
local installed
installed=$(profiles -C -output stdout-xml 2>/dev/null | grep -c "ProfileDisplayName" || true)
if [ "$installed" -gt 0 ]; then
if sudo profiles -D -F 2>/dev/null; then
success "Forced profile removal"
else
warn "Profile removal failed"
fi
else
info "No installed profiles to remove"
fi
else
warn "profiles command not available"
fi
step "Cleaning user LaunchAgents..."
local home users_root="${1:-}/Users"
for home in "$users_root/"*/; do
[ -d "$home/Library/LaunchAgents" ] || continue
local cleaned=0
for agent in "$home/Library/LaunchAgents/"*; do
[ -f "$agent" ] || continue
if grep -qiE "(mdm|enrollment|managedclient|depnotify)" "$agent" 2>/dev/null; then
rm -f "$agent"
cleaned=$((cleaned + 1))
fi
done
if [ "$cleaned" -gt 0 ]; then
success "$(basename "$home"): removed $cleaned agent(s)"
else
info "$(basename "$home"): clean"
fi
done
step "Flushing DNS cache..."
if command -v dscacheutil &>/dev/null; then
sudo dscacheutil -flushcache && success "DNS cache flushed"
fi
if command -v killall &>/dev/null; then
sudo killall -HUP mDNSResponder 2>/dev/null && success "mDNSResponder restarted" || true
fi
step "Checking for MDM keychain items..."
if command -v security &>/dev/null; then
local identities
identities=$(sudo security find-identity -p basic 2>/dev/null | grep -ci mdm || true)
if [ "$identities" -gt 0 ]; then
warn "$identities MDM-related identity(ies) found in keychain"
warn "Manual review recommended: security find-identity -p basic | grep -i mdm"
else
info "No MDM identities found in keychain"
fi
else
warn "security command not available"
fi
step "Checking for JAMF/Intune/Workspace ONE agents..."
for agent_bin in /usr/local/bin/jamf /usr/local/bin/intune /opt/cisco/anyconnect/bin/*; do
if [ -f "$agent_bin" ]; then
warn "MDM agent binary found: $agent_bin"
fi
done
step "Disabling iCloud Private Relay (DoH source)..."
if command -v defaults &>/dev/null; then
if sudo defaults write /Library/Preferences/com.apple.networkextensions.plist PrivateRelayEnabled -bool false 2>/dev/null; then
success "Private Relay disabled"
else
info "Private Relay not configurable (expected on some configs)"
fi
fi
echo ""
echo -e "${GRN}============================================${NC}"
echo -e "${GRN} Live-OS Hardening Complete ${NC}"
echo -e "${GRN}============================================${NC}"
echo ""
echo -e "${YEL}Reboot recommended to verify all changes.${NC}"
echo -e "${YEL}For per-app blocking: install Little Snitch or LuLu.${NC}"
}
harden_status() {
step "System extension status..."
if command -v systemextensionsctl &>/dev/null; then
systemextensionsctl list 2>/dev/null | head -20 || true
else
info "systemextensionsctl not available"
fi
step "MDM-related LaunchDaemons loaded..."
launchctl list 2>/dev/null | grep -iE "mdm|managed|enrollment|activation" || info "None loaded"
step "Running MDM processes..."
pgrep -il "mdm|managedclient|activation" 2>/dev/null || info "None running"
}
MDM_BLOCKLIST="mdmenrollment.apple.com deviceenrollment.apple.com iprofiles.apple.com"
install_selective_block() {
local data_mount="$1"
local root=""
[ -n "$data_mount" ] && root="$data_mount"
step "Installing selective pf rules (block MDM only, allow Apple services)..."
local anchor_dir="${root}/etc/pf.anchors"
local anchor_file="${anchor_dir}/com.runaway.selective"
mkdir -p "$anchor_dir"
: > "$anchor_file"
for d in $MDM_BLOCKLIST; do
for ip in $(host -t a "$d" 2>/dev/null | awk '/has address/{print $NF}'); do
echo "block drop out proto {tcp,udp} to {$ip}" >> "$anchor_file"
done
for ip in $(host -t aaaa "$d" 2>/dev/null | awk '/has IPv6 addr/{print $NF}'); do
echo "block drop out proto {tcp,udp} to {$ip}" >> "$anchor_file"
done
done
chmod 644 "$anchor_file"
success "Selective anchor written: $anchor_file"
local pf_conf="${root}/etc/pf.conf"
local anchor_line="anchor \"com.runaway.selective\""
local load_line="load anchor \"com.runaway.selective\" from \"${anchor_file}\""
if [ -f "$pf_conf" ]; then
if grep -q "com.runaway.selective" "$pf_conf" 2>/dev/null; then
info "pf.conf already has selective anchor"
else
printf '\n%s\n%s\n%s\n' "# Added by runaway — selective MDM block (iCloud-safe)" "$anchor_line" "$load_line" >> "$pf_conf"
success "pf.conf updated with selective rules"
fi
else
cat > "$pf_conf" <<- EOF
scrub-anchor "com.apple/*"
nat-anchor "com.apple/*"
rdr-anchor "com.apple/*"
dummynet-anchor "com.apple/*"
fwd-anchor "com.apple/*"
anchor "com.apple/*"
load anchor "com.apple" from "/etc/pf.anchors/com.apple"
# Added by runaway — selective MDM block (iCloud-safe)
${anchor_line}
${load_line}
EOF
success "pf.conf created"
fi
if command -v pfctl &>/dev/null; then
if pfctl -e -f "$pf_conf" 2>/dev/null; then
success "pf rules loaded (iCloud should work)"
else
warn "pfctl failed"
fi
fi
}
restore_hosts_based_block() {
local data_mount="$1"
local root=""
[ -n "$data_mount" ] && root="$data_mount"
local hosts="${root}/private/etc/hosts"
if [ -f "$hosts" ] && grep -q "Added by runaway" "$hosts" 2>/dev/null; then
info "runaway hosts entries intact"
fi
}
run_preformat_check() {
header "Pre-Format MDM Assessment"
local clean=true
step "Checking DEP activation record..."
if [ -f "/private/var/db/ConfigurationProfiles/Settings/.cloudConfigRecordFound" ]; then
local org
org=$(plutil -convert xml1 -o - "/private/var/db/ConfigurationProfiles/Settings/.cloudConfigRecordFound" 2>/dev/null \
| grep -iA1 OrganizationName | tail -1 | sed -E 's/.*<string>(.*)<\/string>.*/\1/')
echo -e " ${RED}ACTIVE DEP RECORD FOUND${NC}"
[ -n "$org" ] && echo -e " ${YEL}Device assigned to: $org${NC}"
clean=false
else
echo -e " ${GRN}DEP record clean${NC}"
fi
step "Checking MDM enrollment URL for this device..."
if command -v curl &>/dev/null; then
local enroll_check
enroll_check=$(curl -s -o /dev/null -w "%{http_code}" --max-time 5 \
"https://deviceenrollment.apple.com/" 2>/dev/null || echo "000")
if [ "$enroll_check" = "000" ] || [ "$enroll_check" = "200" ]; then
echo -e " ${YEL}deviceenrollment.apple.com reachable${NC}"
else
echo -e " ${GRN}deviceenrollment.apple.com blocked (code $enroll_check)${NC}"
fi
else
echo -e " ${YEL}curl not available, skipping URL check${NC}"
fi
step "Checking MDM enrollment state..."
if command -v profiles &>/dev/null; then
local enroll_state
enroll_state=$(sudo profiles status -type enrollment 2>/dev/null || true)
if echo "$enroll_state" | grep -qi "enrolled"; then
echo -e " ${RED}Device is enrolled in MDM${NC}"
clean=false
else
echo -e " ${GRN}Not enrolled in MDM${NC}"
fi
fi
step "Checking installed profiles..."
if command -v profiles &>/dev/null; then
local profile_count
profile_count=$(sudo profiles -C -output stdout-xml 2>/dev/null | grep -c "ProfileDisplayName" || true)
profile_count="${profile_count:-0}"
if [ "$profile_count" -gt 0 ]; then
echo -e " ${YEL}$profile_count profile(s) installed${NC}"
clean=false
else
echo -e " ${GRN}No profiles installed${NC}"
fi
fi
step "Checking pf firewall status..."
if command -v pfctl &>/dev/null; then
if pfctl -a "com.runaway/mdm" -s rules 2>/dev/null | grep -q "block"; then
echo -e " ${GRN}Runaway pf firewall active${NC}"
else
echo -e " ${YEL}No Runaway pf firewall rules${NC}"
fi
else
echo -e " ${YEL}pfctl not available${NC}"
fi
step "Checking persistence LaunchDaemon..."
if [ -f "/Library/LaunchDaemons/com.runaway.heal.plist" ]; then
echo -e " ${GRN}Runaway LaunchDaemon installed (auto-heal on boot)${NC}"
else
echo -e " ${YEL}No Runaway LaunchDaemon${NC}"
fi
echo ""
echo -e "${CYAN}╔══════════════════════════════════════════════════════════════╗${NC}"
if [ "$clean" = true ]; then
echo -e "${CYAN}║${NC} ${GRN}SAFE TO FORMAT${NC} — No MDM enrollment detected ${CYAN}║${NC}"
echo -e "${CYAN}║${NC} This Mac should not lock after a wipe. ${CYAN}║${NC}"
echo -e "${CYAN}║${NC} If you want defense-in-depth anyway, run: ${CYAN}║${NC}"
echo -e "${CYAN}║${NC} ${YEL}sudo ./runaway persist && sudo ./runaway firewall${NC} ${CYAN}║${NC}"
else
echo -e "${CYAN}║${NC} ${RED}MDM DETECTED${NC} — This Mac WILL lock after format ${CYAN}║${NC}"
echo -e "${CYAN}║${NC} Run from Recovery after wipe: ${YEL}./runaway bypass${NC} ${CYAN}║${NC}"
echo -e "${CYAN}║${NC} To survive macOS updates (not full wipes): ${CYAN}║${NC}"
echo -e "${CYAN}║${NC} ${YEL}sudo ./runaway persist && sudo ./runaway firewall${NC} ${CYAN}║${NC}"
fi
echo -e "${CYAN}╚══════════════════════════════════════════════════════════════╝${NC}"
}
check_upgrade_safety() {
header "macOS Upgrade Safety Check"
step "Checking if suppression will survive upgrade..."
local issues=0
if [ -f "/Library/LaunchDaemons/com.runaway.heal.plist" ]; then
echo -e " ${GRN}Persistence installed — heal runs after reboot${NC}"
else
echo -e " ${RED}No persistence — upgrade may restore MDM${NC}"
echo -e " ${YEL}Fix: sudo ./runaway persist${NC}"
issues=$((issues + 1))
fi
if command -v pfctl &>/dev/null && pfctl -a "com.runaway/mdm" -s rules 2>/dev/null | grep -q "block"; then
echo -e " ${GRN}pf firewall active — survives upgrade${NC}"
else
echo -e " ${YEL}No pf firewall — upgrade may restore MDM connectivity${NC}"
echo -e " ${YEL}Fix: sudo ./runaway whitelist${NC}"
issues=$((issues + 1))
fi
if grep -q "iprofiles.apple.com" /private/etc/hosts 2>/dev/null; then
echo -e " ${GRN}Hosts block active${NC}"
else
echo -e " ${YEL}Hosts block not found${NC}"
issues=$((issues + 1))
fi
echo ""
if [ "$issues" -eq 0 ]; then
echo -e "${GRN}Upgrade should be safe — MDM suppression will survive.${NC}"
else
echo -e "${YEL}$issues issue(s) found. Run the fixes above before upgrading.${NC}"
fi
}
install_monitor_launchdaemon() {
local data_mount="$1"
local root=""
[ -n "$data_mount" ] && root="$data_mount"
local runaway_src
runaway_src=$(_launchd_script_path)
step "Installing monitor LaunchDaemon..."
local plist_dir="${root}/Library/LaunchDaemons"
local plist_path="${plist_dir}/com.runaway.monitor.plist"
mkdir -p "$plist_dir"
cat > "$plist_path" <<- PLIST
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.runaway.monitor</string>
<key>ProgramArguments</key>
<array>
<string>/bin/bash</string>
<string>${runaway_src}</string>
<string>monitor</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>Nice</key>
<integer>1</integer>
<key>StandardOutPath</key>
<string>/var/log/runaway-monitor.log</string>
<key>StandardErrorPath</key>
<string>/var/log/runaway-monitor.err</string>
</dict>
</plist>
PLIST
chmod 644 "$plist_path"
success "Monitor LaunchDaemon: $plist_path"
if command -v launchctl &>/dev/null; then
if launchctl load "$plist_path" 2>/dev/null; then
success "Monitor loaded (starts at boot)"
else
info "Will load on next boot"
fi
fi
}
uninstall_monitor_launchdaemon() {
local data_mount="$1"
local root=""
[ -n "$data_mount" ] && root="$data_mount"
local plist_path="${root}/Library/LaunchDaemons/com.runaway.monitor.plist"
if [ -f "$plist_path" ]; then
step "Removing monitor LaunchDaemon..."
if command -v launchctl &>/dev/null; then
launchctl unload "$plist_path" 2>/dev/null || true
fi
rm -f "$plist_path"
success "Monitor LaunchDaemon removed"
else
info "No monitor LaunchDaemon installed"
fi
}
monitor_mdm() {
header "MDM Monitor (continuous)"
if ! is_root; then
error_exit "Monitor requires sudo: sudo ./runaway monitor"
fi
local logfile="/var/log/runaway-monitor.log"
local pidfile="/tmp/runaway-monitor.pid"
local webhook="${DISCORD_WEBHOOK:-}"
if [ -f "$pidfile" ] && kill -0 "$(cat "$pidfile")" 2>/dev/null; then
echo -e "${YEL}Monitor already running (PID $(cat "$pidfile"))${NC}"
echo -e "${YEL}Run 'sudo ./runaway monitor-stop' to stop it${NC}"
return 0
fi
echo "$$" > "$pidfile"
local interval=300
local consecutive_failures=0
local last_state=""
local last_notification=0
echo "$(date) Monitor started (interval ${interval}s)" >> "$logfile"
local cfg="/private/var/db/ConfigurationProfiles/Settings"
local hosts="/private/etc/hosts"
trap 'echo "$(date) Monitor stopped" >> "$logfile"; rm -f "$pidfile"; exit 0' INT TERM
while true; do
local state="clean"
local reason=""
if [ -f "$cfg/.cloudConfigRecordFound" ]; then
state="dirty"
reason="DEP record found"
fi
if [ -f "$hosts" ] && ! grep -q "iprofiles.apple.com" "$hosts" 2>/dev/null; then
state="dirty"
reason="Hosts block missing"
fi
if command -v profiles &>/dev/null; then
local enroll_state
enroll_state=$(profiles status -type enrollment 2>/dev/null || true)
if echo "$enroll_state" | grep -qi "Enrolled via DEP"; then
state="dirty"
reason="DEP enrollment active"
fi
fi
if [ "$state" != "$last_state" ]; then
echo "$(date) State change: $last_state -> $state ($reason)" >> "$logfile"
last_state="$state"
local now
now=$(date +%s)
if [ "$state" = "dirty" ] && [ $((now - last_notification)) -gt 3600 ]; then
last_notification=$now
if command -v osascript &>/dev/null; then
osascript -e "display notification \"$reason\" with title \"Runaway MDM Alert\" subtitle \"MDM enrollment detected\"" 2>/dev/null || true
fi
if [ -n "$webhook" ]; then
local payload
payload=$(printf '{"content":"🚨 **Runaway Alert** — MDM enrollment detected: %s","username":"Runaway Monitor"}' "$reason")
curl -s -H "Content-Type: application/json" -d "$payload" "$webhook" 2>/dev/null || warn "Webhook failed"
fi
heal_suppress ""
fi
fi
if [ "$state" = "dirty" ]; then
consecutive_failures=$((consecutive_failures + 1))
else
consecutive_failures=0
fi
if [ "$consecutive_failures" -ge 12 ]; then
echo "$(date) CRITICAL: 12 consecutive dirty checks" >> "$logfile"
if command -v osascript &>/dev/null; then
osascript -e "display dialog \"MDM keeps coming back after 12 attempts. Something is persistently re-enrolling.\" with title \"Runaway\" buttons {\"OK\"} default button \"OK\"" 2>/dev/null || true
fi
if [ -n "$webhook" ]; then
curl -s -H "Content-Type: application/json" \
-d '{"content":"🚨 **Runaway CRITICAL** — 12 consecutive MDM detections. Persistent re-enrollment detected.","username":"Runaway Monitor"}' \
"$webhook" 2>/dev/null || true
fi
consecutive_failures=0
fi
sleep "$interval" &
wait $! 2>/dev/null || true
done
}
stop_monitor() {
local pidfile="${1:-/tmp/runaway-monitor.pid}"
if [ -f "$pidfile" ]; then
local pid
pid=$(cat "$pidfile")
if kill -0 "$pid" 2>/dev/null; then
kill "$pid" 2>/dev/null
echo -e "${GRN}Monitor stopped${NC}"
else
echo -e "${YEL}Monitor not running (stale PID)${NC}"
fi
rm -f "$pidfile"
else
echo -e "${YEL}Monitor not running${NC}"
fi
}
monitor_status() {
local pidfile="${1:-/tmp/runaway-monitor.pid}"
if [ -f "$pidfile" ] && kill -0 "$(cat "$pidfile")" 2>/dev/null; then
echo -e "${GRN}Monitor running (PID $(cat "$pidfile"))${NC}"
tail -5 /var/log/runaway-monitor.log 2>/dev/null || echo " (no log entries yet)"
else
echo -e "${YEL}Monitor not running${NC}"
fi
}
show_history() {
header "Runaway Event History"
local log_dir="${1:-/var/log}"
local logs=("$log_dir/runaway-monitor.log" "$log_dir/runaway-heal.log" "$log_dir/runaway-monitor.err")
local found=false
for logfile in "${logs[@]}"; do
if [ -f "$logfile" ] && [ -s "$logfile" ]; then
found=true
local name
name=$(basename "$logfile")
step "$name"
while IFS= read -r line; do
echo " $line"
done < "$logfile"
echo ""
fi
done
if [ "$found" = false ]; then
info "No event logs found."
info "Run 'sudo ./runaway monitor' or 'sudo ./runaway persist' first."
fi
step "Backup records"
local backup_dir=".runaway-backup"
if [ -d "$backup_dir" ] && [ -f "$backup_dir/timestamp" ]; then
local ts
ts=$(cat "$backup_dir/timestamp")
echo " Last backup: $ts"
else
echo " No backup found"
fi
}
clear_history() {
local log_dir="${1:-/var/log}"
local logs=("$log_dir/runaway-monitor.log" "$log_dir/runaway-heal.log" "$log_dir/runaway-monitor.err")
for logfile in "${logs[@]}"; do
if [ -f "$logfile" ]; then
: > "$logfile"
success "Cleared: $logfile"
fi
done
}
_network_diagnostics() {
header "Network Diagnostics"
local version=unavailable build=unavailable
if command -v sw_vers &>/dev/null; then
version=$(sw_vers -productVersion 2>/dev/null) || version=unavailable
build=$(sw_vers -buildVersion 2>/dev/null) || build=unavailable
fi
printf 'macOS: %s (build %s)\n' "$version" "$build"
case "$version" in 27.*) warn "macOS 27 has limited community reports; see issue #22 for their scope." ;; esac
local interface ports
if ! command -v networksetup >/dev/null; then
warn "Wi-Fi diagnostics unavailable: networksetup is missing."
return 1
fi
if ! ports=$(networksetup -listallhardwareports 2>/dev/null); then
warn "Could not query Wi-Fi hardware ports."
return 1
fi
interface=$(printf '%s\n' "$ports" | awk '
/Hardware Port:/ { wifi=($0 ~ /: (Wi-Fi|AirPort)$/); next }
wifi && /^[[:space:]]*Device:/ { print $2; exit }
' || true)
if [ -z "$interface" ]; then
info "No Wi-Fi hardware port reported."
return 0
fi
local power status details ipv4
if ! power=$(networksetup -getairportpower "$interface" 2>/dev/null); then
warn "Could not query Wi-Fi power."
return 1
fi
if ! details=$(ifconfig "$interface" 2>/dev/null); then
warn "Could not query Wi-Fi link state."
return 1
fi
case "$power" in *': On') power=on ;; *': Off') power=off ;; *) power=unavailable ;; esac
status=$(printf '%s\n' "$details" | awk '/^[[:space:]]*status:/ {print $2; exit}' || true)
ipv4=$(printf '%s\n' "$details" | awk '
/^[[:space:]]*inet / {
if ($2 ~ /^169[.]254[.]/) { state="link-local"; next }
if ($2 != "0.0.0.0") { state="configured"; exit }
}
END { print (state ? state : "none") }
')
printf 'Wi-Fi interface: %s\nWi-Fi power: %s\nLink status: %s\nWi-Fi IPv4: %s\n' "$interface" "$power" "${status:-unavailable}" "$ipv4"
}
run_doctor() {
if [ "${1:-}" = --network ]; then _network_diagnostics; return; fi
header "Runaway Doctor — Pre-Flight Check"
local errors=0 warnings=0
begin "Script location"
local script_dir="${SCRIPT_DIR:-}"
if [ -n "$script_dir" ] && [ -d "$script_dir" ]; then
end_ok; echo " $script_dir"
else
end_fail; errors=$((errors + 1))
fi
begin "Library files"
local missing=0
if [ "${STANDALONE_BUILD:-false}" = true ]; then
local core
for core in log resolve_data_volume validate_username create_admin_user suppress_enrollment backup_state deep_status _launchd_script_path heal_suppress install_pf_mdm_block harden_live_os install_selective_block run_preformat_check monitor_mdm show_history; do
declare -F "$core" >/dev/null || missing=$((missing + 1))
done
else
local lib_dir="${LIB_DIR:-}"
for _lib in colors detect validate dscl suppress backup status launchd heal firewall harden whitelist check monitor history; do
[ -n "$lib_dir" ] && [ -f "$lib_dir/$_lib.sh" ] || missing=$((missing + 1))
done
fi
if [ "$missing" -eq 0 ]; then
end_ok
if [ "${STANDALONE_BUILD:-false}" = true ]; then echo " Embedded core modules loaded";
else echo " Core library files available"; fi
else
end_fail; echo " $missing module(s) missing"; errors=$((errors + 1))
fi
begin "Root privileges"
if is_root; then
end_ok
else
end_fail; echo " Run with sudo for full checks"
warnings=$((warnings + 1))
fi
begin "Recovery mode"
if is_recovery; then
end_ok; echo " Full bypass available"
else
end_fail; echo " Limited to booted-system commands"
warnings=$((warnings + 1))
fi
begin "Disk space (Data volume)"
local avail
avail=$(df / 2>/dev/null | awk 'NR>1 {print $4; exit}')
if [ -n "$avail" ] && [ "$avail" -gt 1048576 ]; then
end_ok; echo " $(echo "$avail" | awk '{printf "%.0f MB", $1/1024}') free"
elif [ -n "$avail" ]; then
end_fail; echo " Low disk space"; warnings=$((warnings + 1))
else
end_fail; echo " Cannot determine"; errors=$((errors + 1))
fi
begin "Internet access"
if command -v curl &>/dev/null && curl -s --max-time 3 https://github.com >/dev/null 2>&1; then
end_ok; echo " Online"
else
end_fail; echo " Offline (expected in Recovery)"
fi
begin "pfctl available"
if command -v pfctl &>/dev/null; then
end_ok
else
end_fail; echo " Firewall commands unavailable"
fi
begin "profiles command"
if command -v profiles &>/dev/null; then
end_ok
else
end_fail; echo " Audit/harden commands limited"
fi
begin "launchctl available"
if command -v launchctl &>/dev/null; then
end_ok
else
end_fail; echo " Persistence commands unavailable"
fi
begin "Third-party firewall"
local tp_found=""
[ -d "/Applications/Little Snitch.app" ] && tp_found="Little Snitch"
[ -d "/Applications/LuLu.app" ] && tp_found="${tp_found:+$tp_found, }LuLu"
[ -f "/Library/Extensions/LittleSnitch.kext" ] && tp_found="${tp_found:+$tp_found, }Little Snitch (kext)"
[ -d "/Applications/Radio Silence.app" ] && tp_found="${tp_found:+$tp_found, }Radio Silence"
[ -d "/Applications/Vallum.app" ] && tp_found="${tp_found:+$tp_found, }Vallum"
if [ -n "$tp_found" ]; then
end_ok; echo " $tp_found"
else
end_fail; echo " None detected"
fi
echo ""
step "Persistence status"
if [ -f "/Library/LaunchDaemons/com.runaway.heal.plist" ]; then
echo " heal LaunchDaemon: installed"
else
echo " heal LaunchDaemon: not installed"
fi
if [ -f "/Library/LaunchDaemons/com.runaway.monitor.plist" ]; then
echo " monitor LaunchDaemon: installed"
else
echo " monitor LaunchDaemon: not installed"
fi
if [ -f "/etc/pf.anchors/com.runaway/mdm" ]; then
echo " pf firewall anchor: installed"
else
echo " pf firewall anchor: not installed"
fi
if [ -f "/etc/pf.anchors/com.runaway.selective" ]; then
echo " pf selective anchor: installed"
else
echo " pf selective anchor: not installed"
fi
echo ""
echo -e "${CYAN}╔══════════════════════════════════════╗${NC}"
if [ "$errors" -eq 0 ] && [ "$warnings" -eq 0 ]; then
echo -e "${CYAN}║${NC} ${GRN}All checks passed${NC} ${CYAN}║${NC}"
elif [ "$errors" -eq 0 ]; then
echo -e "${CYAN}║${NC} ${YEL}Passed with $warnings warning(s)${NC} ${CYAN}║${NC}"
else
echo -e "${CYAN}║${NC} ${RED}$errors error(s), $warnings warning(s)${NC} ${CYAN}║${NC}"
fi
echo -e "${CYAN}╚══════════════════════════════════════╝${NC}"
}
GPG_KEY_URL="https://raw.githubusercontent.com/mateussiqueira/runaway/main/.github/runaway.gpg"
import_gpg_key() {
local tmp_key
tmp_key=$(mktemp)
if curl -sL "$GPG_KEY_URL" -o "$tmp_key" 2>/dev/null; then
gpg --import "$tmp_key" 2>/dev/null || true
fi
rm -f "$tmp_key"
}
verify_gpg_signature() {
local file="$1"
local sig="$2"
if ! command -v gpg &>/dev/null; then
warn "GPG not available — skipping signature verification"
return 0
fi
import_gpg_key
if gpg --verify "$sig" "$file" 2>/dev/null; then
info "GPG signature valid"
return 0
else
warn "GPG signature invalid or missing"
echo -n "Continue without verification? [y/N] "
read -r ans
[ "$ans" != "y" ] && [ "$ans" != "Y" ] && error_exit "Aborted"
return 0
fi
}
do_self_update() {
header "Runaway Update"
if ! command -v curl &>/dev/null; then
error_exit "curl required for update"
fi
local repo="mateussiqueira/runaway"
local api_url="https://api.github.com/repos/${repo}/releases/latest"
local tmp_dir
tmp_dir=$(mktemp -d)
begin "Checking latest release"
local release_data
release_data=$(curl -s "$api_url" 2>/dev/null || true)
local latest_tag
latest_tag=$(echo "$release_data" | grep '"tag_name"' | head -1 | sed -E 's/.*"v?([^"]+)".*/\1/')
if [ -z "$latest_tag" ]; then
end_fail; echo " No network or invalid response"
rm -rf "$tmp_dir"
return 1
fi
end_ok; echo " Latest: v$latest_tag"
if [ "v$latest_tag" = "v$VERSION" ]; then
success "Already up to date (v$VERSION)"
rm -rf "$tmp_dir"
return 0
fi
info "Updating from v$VERSION to v$latest_tag..."
begin "Downloading latest runaway"
local dl_url="https://raw.githubusercontent.com/${repo}/main/runaway"
local sig_url="${dl_url}.sig"
local tmp="$tmp_dir/runaway"
local sig_tmp="$tmp_dir/runaway.sig"
if curl -sL "$dl_url" -o "$tmp" && [ -s "$tmp" ]; then
curl -sL "$sig_url" -o "$sig_tmp" 2>/dev/null || true
end_ok
else
end_fail; error_exit "Download failed"
fi
if [ -s "$sig_tmp" ]; then
begin "Verifying GPG signature"
verify_gpg_signature "$tmp" "$sig_tmp"
end_ok
fi
begin "Verifying syntax"
if bash -n "$tmp" 2>/dev/null; then
end_ok
else
end_fail; error_exit "Downloaded script has syntax errors"
fi
local target="${0:-runaway}"
if [ ! -w "$target" ]; then
info "$target not writable, trying sudo..."
cp "$tmp" "$target" 2>/dev/null || sudo cp "$tmp" "$target" 2>/dev/null || {
error_exit "Cannot write to $target (run with sudo)"
}
else
cp "$tmp" "$target"
fi
chmod +x "$target" 2>/dev/null || sudo chmod +x "$target" 2>/dev/null || true
rm -rf "$tmp_dir"
success "Updated to v$latest_tag"
info "Run again to use new version"
}
do_uninstall() {
header "Runaway — Full Uninstall"
if ! is_root; then
error_exit "Uninstall needs sudo: sudo ./runaway uninstall"
fi
begin "Removing heal LaunchDaemon"
local plist="/Library/LaunchDaemons/com.runaway.heal.plist"
if [ -f "$plist" ]; then
launchctl unload "$plist" 2>/dev/null || true
rm -f "$plist"
end_ok
else
end_fail; echo " Not installed"
fi
begin "Removing monitor LaunchDaemon"
plist="/Library/LaunchDaemons/com.runaway.monitor.plist"
if [ -f "$plist" ]; then
launchctl unload "$plist" 2>/dev/null || true
rm -f "$plist"
end_ok
else
end_fail; echo " Not installed"
fi
begin "Cleaning pf anchors"
local anchors=("/etc/pf.anchors/com.runaway/mdm" "/etc/pf.anchors/com.runaway.selective")
for a in "${anchors[@]}"; do
[ -f "$a" ] && rm -f "$a"
done
for anchor_name in "com.runaway/mdm" "com.runaway.selective"; do
pfctl -a "$anchor_name" -F all 2>/dev/null || true
done
local pf_conf="/etc/pf.conf"
if [ -f "$pf_conf" ]; then
sed -i '' '/# Added by runaway/d' "$pf_conf" 2>/dev/null || true
sed -i '' '/com\.runaway/d' "$pf_conf" 2>/dev/null || true
fi
pfctl -f /etc/pf.conf 2>/dev/null || true
end_ok
begin "Cleaning hosts entries"
local hosts="/private/etc/hosts"
if [ -f "$hosts" ]; then
sed -i '' '/# Added by runaway/d' "$hosts" 2>/dev/null || true
local domains=("iprofiles.apple.com" "deviceenrollment.apple.com" "mdmenrollment.apple.com")
for d in "${domains[@]}"; do
sed -i '' "/[[:space:]]$d/d" "$hosts" 2>/dev/null || true
sed -i '' "/::$d/d" "$hosts" 2>/dev/null || true
done
end_ok
else
end_fail; echo " Not found"
fi
begin "Restoring launchd overrides"
local ldp="/private/var/db/com.apple.xpc.launchd/disabled.plist"
if [ -f "$ldp" ]; then
for label in com.apple.ManagedClient.enroll com.apple.ManagedClient.cloudConfiguration \
com.apple.mdmclient.daemon.runatboot com.apple.activationd; do
/usr/libexec/PlistBuddy -c "Delete :$label" "$ldp" 2>/dev/null || true
done
end_ok
else
end_fail; echo " Not found"
fi
begin "Removing backup directory"
local backup=".runaway-backup"
if [ -d "$backup" ]; then
rm -rf "$backup" 2>/dev/null || true
end_ok
else
end_fail; echo " Not found"
fi
begin "Removing config file"
if [ -f "$HOME/.runaway.conf" ]; then
rm -f "$HOME/.runaway.conf"
end_ok
else
end_fail; echo " Not found"
fi
begin "Stopping monitor if running"
local pidfile="/tmp/runaway-monitor.pid"
if [ -f "$pidfile" ]; then
kill "$(cat "$pidfile")" 2>/dev/null || true
rm -f "$pidfile"
end_ok
else
end_fail; echo " Not running"
fi
echo ""
success "Uninstall complete"
info "Your system is back to its original state."
info "The runaway script itself was not removed."
}
generate_report() {
if [ "${1:-}" = "--json" ]; then
generate_report_json
return
fi
header "Runaway System Report"
local ts
ts=$(date '+%Y-%m-%d %H:%M:%S')
echo "Generated: $ts"
echo "Version: $VERSION"
echo ""
step "MDM Enrollment State"
if command -v profiles &>/dev/null; then
sudo profiles status -type enrollment 2>/dev/null || echo " (cannot determine)"
fi
local cfg="/private/var/db/ConfigurationProfiles/Settings"
if [ -f "$cfg/.cloudConfigRecordFound" ]; then
local org
org=$(plutil -convert xml1 -o - "$cfg/.cloudConfigRecordFound" 2>/dev/null \
| grep -iA1 OrganizationName | tail -1 | sed -E 's/.*<string>(.*)<\/string>.*/\1/')
echo " DEP record: FOUND${org:+ (Organization: $org)}"
else
echo " DEP record: clean"
fi
echo ""
step "Installed Profiles"
if command -v profiles &>/dev/null; then
local count
count=$(sudo profiles -C -output stdout-xml 2>/dev/null | grep -c "ProfileDisplayName" || true)
count="${count:-0}"
if [ "$count" -gt 0 ]; then
echo " $count profile(s) installed"
sudo profiles -C -output stdout-xml 2>/dev/null | grep -A1 "ProfileDisplayName" | grep "<string>" \
| sed 's/.*<string>\(.*\)<\/string>.*/ - \1/'
else
echo " No profiles installed"
fi
fi
echo ""
step "Firewall"
if command -v pfctl &>/dev/null; then
pfctl -si 2>/dev/null | grep -E "Status|Enabled" || echo " pf not enabled"
echo ""
pfctl -a "com.runaway/mdm" -s rules 2>/dev/null \
&& echo " Runaway MDM anchor: active" \
|| echo " Runaway MDM anchor: not loaded"
pfctl -a "com.runaway.selective" -s rules 2>/dev/null \
&& echo " Runaway selective anchor: active" \
|| echo " Runaway selective anchor: not loaded"
fi
echo ""
step "Persistence"
[ -f "/Library/LaunchDaemons/com.runaway.heal.plist" ] \
&& echo " heal LaunchDaemon: installed" \
|| echo " heal LaunchDaemon: not installed"
[ -f "/Library/LaunchDaemons/com.runaway.monitor.plist" ] \
&& echo " monitor LaunchDaemon: installed" \
|| echo " monitor LaunchDaemon: not installed"
[ -f "/tmp/runaway-monitor.pid" ] \
&& echo " monitor process: running" \
|| echo " monitor process: not running"
echo ""
step "Recent Events"
for logfile in /var/log/runaway-monitor.log /var/log/runaway-heal.log; do
if [ -f "$logfile" ] && [ -s "$logfile" ]; then
echo " From $(basename "$logfile"):"
tail -3 "$logfile" | sed 's/^/ /'
fi
done
echo ""
step "Hosts Block"
if grep -q "iprofiles.apple.com" /private/etc/hosts 2>/dev/null; then
local blocked
blocked=$(grep -c "0.0.0.0" /private/etc/hosts 2>/dev/null || true)
blocked="${blocked:-0}"
echo " $blocked domain(s) blocked in /etc/hosts"
else
echo " No block entries found"
fi
echo ""
step "Running MDM Processes"
local procs
procs=$(pgrep -il "mdm|managedclient|activation" 2>/dev/null || true)
if [ -n "$procs" ]; then
echo "$procs" | awk '{print " " $2 " (PID " $1 ")"}'
else
echo " None"
fi
}
generate_report_json() {
local report=""
report="${report}{\n"
report="${report} \"version\": \"$VERSION\",\n"
report="${report} \"timestamp\": \"$(date -u '+%Y-%m-%dT%H:%M:%SZ')\",\n"
local enroll_state="unknown"
if command -v profiles &>/dev/null; then
enroll_state=$(sudo profiles status -type enrollment 2>/dev/null | head -1 | xargs || echo "unknown")
fi
enroll_state="${enroll_state//\"/\\\"}"
report="${report} \"enrollment_state\": \"${enroll_state}\",\n"
local has_dep="false"
if [ -f "/private/var/db/ConfigurationProfiles/Settings/.cloudConfigRecordFound" ]; then
has_dep="true"
fi
report="${report} \"dep_record_found\": $has_dep,\n"
local profile_count=0
if command -v profiles &>/dev/null; then
profile_count=$(sudo profiles -C -output stdout-xml 2>/dev/null | grep -c "ProfileDisplayName" || true)
profile_count="${profile_count:-0}"
fi
report="${report} \"installed_profiles\": $profile_count,\n"
local heal_installed="false"
[ -f "/Library/LaunchDaemons/com.runaway.heal.plist" ] && heal_installed="true"
local monitor_installed="false"
[ -f "/Library/LaunchDaemons/com.runaway.monitor.plist" ] && monitor_installed="true"
local monitor_running="false"
[ -f "/tmp/runaway-monitor.pid" ] && monitor_running="true"
report="${report} \"persistence\": {\n"
report="${report} \"heal_launchdaemon\": $heal_installed,\n"
report="${report} \"monitor_launchdaemon\": $monitor_installed,\n"
report="${report} \"monitor_running\": $monitor_running\n"
report="${report} },\n"
local fw_active="false"
if command -v pfctl &>/dev/null && pfctl -a "com.runaway/mdm" -s rules 2>/dev/null | grep -q "block"; then
fw_active="true"
fi
local selective_active="false"
if command -v pfctl &>/dev/null && pfctl -a "com.runaway.selective" -s rules 2>/dev/null | grep -q "block"; then
selective_active="true"
fi
report="${report} \"firewall\": {\n"
report="${report} \"mdm_block_active\": $fw_active,\n"
report="${report} \"selective_block_active\": $selective_active\n"
report="${report} },\n"
local hosts_blocked=0
hosts_blocked=$(grep -c "0.0.0.0" /private/etc/hosts 2>/dev/null || true)
hosts_blocked="${hosts_blocked:-0}"
report="${report} \"hosts_blocked\": $hosts_blocked\n"
report="${report}}"
echo -e "$report"
}
_has_matching_path() {
local path
for path in "$@"; do
[ ! -e "$path" ] || return 0
done
return 1
}
detect_configurator_enrollment() {
local data_mount="${1:-}"
header "Apple Configurator / ASM Enrollment Check"
local sys_dir
if [ -n "$data_mount" ] && [ -d "$data_mount/private/var/db" ]; then
sys_dir="$data_mount/private/var/db"
elif [ -d "/private/var/db" ]; then
sys_dir="/private/var/db"
else
warn "Cannot locate system database directory"
return 1
fi
local indicators=0
# Configurator enrollment flag
if [ -f "$sys_dir/ConfigurationProflements/Setup/.configuratorEnrollment" ]; then
echo -e "${YEL}⚠ Apple Configurator enrollment detected${NC}"
indicators=$((indicators + 1))
fi
# Check for ASM/ABM cloud config records
for f in "$sys_dir"/ConfigurationProfiles/Settings/.cloudConfig*; do
[ -f "$f" ] || continue
local name
name=$(basename "$f")
echo -e "${YEL} DEP marker present: $name${NC}"
indicators=$((indicators + 1))
done
# Enrollment challenge tokens
local challenge_dir="$sys_dir/ConfigurationProflements/Setup"
if [ -f "$challenge_dir/.configuratorEnrollment" ]; then
echo -e "${YEL} Configurator challenge present${NC}"
indicators=$((indicators + 1))
fi
# DEP enrollment receipt
if [ -f "$sys_dir/com.apple.DEPReceipt" ]; then
echo -e "${YEL} DEP receipt found${NC}"
indicators=$((indicators + 1))
fi
if [ "$indicators" -eq 0 ]; then
echo -e "${GRN}✓ No Configurator/ASM enrollment detected${NC}"
return 0
else
echo ""
echo -e "${YEL}Fix: re-run bypass from Recovery, then run 'sudo ./runaway harden'${NC}"
return 1
fi
}
detect_migration_assistant() {
local data_mount="${1:-}"
header "Migration Assistant Check"
local homes=()
if [ -n "$data_mount" ] && [ -d "$data_mount/Users" ]; then
for h in "$data_mount/Users/"*/; do
homes+=("$h")
done
elif [ -d "/Users" ]; then
for h in /Users/*/; do
homes+=("$h")
done
fi
local ma_indicators=0
local details=""
for home in "${homes[@]}"; do
local user
user=$(basename "$home")
[ "$user" = "Guest" ] || [ "$user" = "Shared" ] && continue
[ -d "$home/Library" ] || continue
local user_agents="$home/Library/LaunchAgents"
if [ -d "$user_agents" ]; then
local found=0 agent
for agent in "$user_agents/"*; do
[ -f "$agent" ] || continue
if printf '%s\n' "${agent##*/}" | grep -qiE 'mdm|enrollment|managed'; then
found=$((found + 1))
fi
done
if [ "$found" -gt 0 ]; then
ma_indicators=$((ma_indicators + found))
details="$details $user: $found MDM LaunchAgent(s)\n"
fi
fi
local prefs="$home/Library/Preferences"
if [ -d "$prefs" ]; then
if _has_matching_path "$prefs"/com.apple.mdm* "$prefs"/com.apple.ManagedClient*; then
ma_indicators=$((ma_indicators + 1))
details="$details $user: MDM preference files\n"
fi
fi
local support="$home/Library/Application Support/com.apple.ManagedClient"
if [ -d "$support" ]; then
ma_indicators=$((ma_indicators + 1))
details="$details $user: ManagedClient Application Support\n"
fi
local caches="$home/Library/Caches"
if [ -d "$caches" ]; then
if _has_matching_path "$caches"/com.apple.enrollment*; then
ma_indicators=$((ma_indicators + 1))
details="$details $user: enrollment cache files\n"
fi
if _has_matching_path "$caches"/com.apple.mdm*; then
ma_indicators=$((ma_indicators + 1))
details="$details $user: MDM cache files\n"
fi
fi
local keychains="$home/Library/Keychains"
if [ -f "$keychains/OCSPCache.plist" ]; then
local ocsp_mdm
ocsp_mdm=$(grep -l "mdm" "$keychains/OCSPCache.plist" 2>/dev/null || true)
if [ -n "$ocsp_mdm" ]; then
ma_indicators=$((ma_indicators + 1))
details="$details $user: MDM OCSP cache\n"
fi
fi
done
if [ "$ma_indicators" -gt 0 ]; then
echo -e "${YEL}⚠ Migration Assistant artifacts detected (severity: $ma_indicators):${NC}"
echo -e "$details" | sed '/^$/d'
echo ""
echo -e "${YEL}These user-level artifacts can re-enable MDM on every login.${NC}"
echo -e "${YEL}Fix: run 'sudo ./runaway harden' or './runaway suppress' from Recovery.${NC}"
return 1
else
echo -e "${GRN}✓ No Migration Assistant artifacts found${NC}"
return 0
fi
}
clean_ma_artifacts() {
local data_mount="${1:-}"
local homes=()
if [ -n "$data_mount" ] && [ -d "$data_mount/Users" ]; then
for h in "$data_mount/Users/"*/; do homes+=("$h"); done
elif [ -d "/Users" ]; then
for h in /Users/*/; do homes+=("$h"); done
fi
for home in "${homes[@]}"; do
local user
user=$(basename "$home")
[ "$user" = "Guest" ] || [ "$user" = "Shared" ] && continue
[ -d "$home/Library" ] || continue
rm -f "$home/Library/Preferences/com.apple.mdm.plist" 2>/dev/null || true
rm -f "$home/Library/Preferences/com.apple.mdmclient.plist" 2>/dev/null || true
rm -f "$home/Library/Preferences/com.apple.ManagedClient.plist" 2>/dev/null || true
rm -rf "$home/Library/Caches/com.apple.enrollmenttool" 2>/dev/null || true
rm -rf "$home/Library/Caches/com.apple.mdm" 2>/dev/null || true
rm -rf "$home/Library/Application Support/com.apple.ManagedClient" 2>/dev/null || true
done
info "User-level MDM artifacts cleaned"
}
run_demo() {
header "Runaway Demo — Simulated MDM Bypass"
local demo_dir
demo_dir=$(mktemp -d)
mkdir -p "$demo_dir/private/etc"
mkdir -p "$demo_dir/private/var/db/ConfigurationProfiles/Settings"
mkdir -p "$demo_dir/private/var/db/com.apple.xpc.launchd"
mkdir -p "$demo_dir/Users/demo/Library/Preferences"
mkdir -p "$demo_dir/Users/demo/Library/Application Support"
touch "$demo_dir/private/var/db/ConfigurationProfiles/Settings/.cloudConfigRecordFound"
touch "$demo_dir/Users/demo/Library/Preferences/com.apple.mdm.plist"
echo ""
step "1. Simulating pre-bypass MDM state"
echo " DEP record: ${RED}PRESENT${NC}"
echo " Hosts block: ${RED}ABSENT${NC}"
echo " Daemon override: ${RED}ABSENT${NC}"
echo " User artifacts: ${RED}PRESENT${NC}"
sleep 1
echo ""
step "2. Running suppress_enrollment..."
DRY_RUN=false
suppress_enrollment "$demo_dir" 2>/dev/null || true
sleep 1
echo ""
step "3. Verifying post-bypass state"
local clean=true
if [ -f "$demo_dir/private/var/db/ConfigurationProfiles/Settings/.cloudConfigRecordFound" ]; then
echo " DEP record: ${RED}STILL PRESENT (bug)${NC}"
clean=false
else
echo " DEP record: ${GRN}CLEARED${NC}"
fi
if grep -q "iprofiles.apple.com" "$demo_dir/private/etc/hosts" 2>/dev/null; then
echo " Hosts block: ${GRN}ACTIVE${NC}"
else
echo " Hosts block: ${RED}ABSENT (bug)${NC}"
clean=false
fi
if [ -f "$demo_dir/Users/demo/Library/Preferences/com.apple.mdm.plist" ]; then
echo " User artifacts: ${RED}STILL PRESENT (bug)${NC}"
clean=false
else
echo " User artifacts: ${GRN}CLEANED${NC}"
fi
echo ""
step "4. Simulating macOS update (re-enabling daemons)"
rm -f "$demo_dir/private/var/db/com.apple.xpc.launchd/disabled.plist"
echo " Daemon override: ${RED}RESET (simulating update)${NC}"
sleep 1
echo ""
step "5. Running heal — detecting and fixing..."
heal_suppress "$demo_dir" 2>/dev/null || true
sleep 1
if [ -f "$demo_dir/private/var/db/com.apple.xpc.launchd/disabled.plist" ]; then
echo " Daemon override: ${GRN}RESTORED${NC}"
fi
echo ""
step "6. Summary"
if [ "$clean" = true ]; then
echo -e " ${GRN}✓ Demo completed successfully${NC}"
else
echo -e " ${YEL}⚠ Demo completed with warnings${NC}"
fi
echo " Simulated environment: $demo_dir"
echo ""
info "This is a simulated run. No real system was modified."
info "Run 'rm -rf $demo_dir' to clean up."
echo ""
echo -e "${CYAN}╔═══════════════════════════════════════════════╗${NC}"
echo -e "${CYAN}║${NC} ${GRN}Demo Complete${NC} ${CYAN}║${NC}"
echo -e "${CYAN}║${NC} Commands used: suppress, heal ${CYAN}║${NC}"
echo -e "${CYAN}║${NC} Try: ${YEL}sudo ./runaway doctor${NC} for real diagnostics ${CYAN}║${NC}"
echo -e "${CYAN}╚═══════════════════════════════════════════════╝${NC}"
}
VPN_RULES_ANCHOR="com.runaway/vpn-kill"
VPN_RULES_FILE="/etc/pf.anchors/com.runaway/vpn-kill"
vpn_kill_install() {
header "VPN Kill-Switch — MDM Leak Protection"
if ! is_root; then
error_exit "VPN kill-switch needs sudo: sudo ./runaway vpn-kill"
fi
local vpn_if=""
step "Detecting active VPN interfaces..."
local interfaces
interfaces=$(ifconfig 2>/dev/null | grep -E "^utun[0-9]+:" | sed 's/:.*//' || true)
if [ -z "$interfaces" ]; then
warn "No VPN interfaces detected"
info "You can specify manually: sudo ./runaway vpn-kill --interface utunX"
info "Common VPN interfaces: utun0-9 (WireGuard), utun10+ (OpenVPN), ppp0 (L2TP)"
else
for iface in $interfaces; do
local addr
addr=$(ifconfig "$iface" 2>/dev/null | awk '/inet /{print $2}')
if [ -n "$addr" ]; then
echo " $iface: $addr"
[ -z "$vpn_if" ] && vpn_if="$iface"
fi
done
fi
local user_if="${2:-}"
[ -n "$user_if" ] && vpn_if="$user_if"
if [ -z "$vpn_if" ]; then
warn "No active VPN detected. Installing kill-switch anyway (no default route)."
info "Usage: sudo ./runaway vpn-kill --interface utunX"
return 1
fi
step "Installing pf rules for VPN kill-switch..."
local anchor_dir="/etc/pf.anchors/com.runaway"
mkdir -p "$anchor_dir"
cat > "$VPN_RULES_FILE" << RULES
# Runaway VPN kill-switch
# Only allow MDM traffic through VPN interface $vpn_if
block drop out proto {tcp,udp} to {17.0.0.0/8, 17.128.0.0/10}
pass out proto {tcp,udp} to {17.0.0.0/8, 17.128.0.0/10} no state
pass on $vpn_if
RULES
chmod 644 "$VPN_RULES_FILE"
success "VPN kill-switch rules installed for $vpn_if"
local pf_conf="/etc/pf.conf"
local anchor_line="anchor \"${VPN_RULES_ANCHOR}\""
local load_line="load anchor \"${VPN_RULES_ANCHOR}\" from \"${VPN_RULES_FILE}\""
if grep -q "vpn-kill" "$pf_conf" 2>/dev/null; then
info "pf.conf already has VPN kill-switch anchor"
else
printf '\n%s\n%s\n%s\n' "# Added by runaway — VPN kill-switch (prevents MDM leaks)" "$anchor_line" "$load_line" >> "$pf_conf"
fi
if pfctl -e -f "$pf_conf" 2>/dev/null; then
success "VPN kill-switch active"
else
warn "pfctl failed"
fi
echo ""
info "What this does:"
info " - Blocks MDM Apple IP ranges (17.0.0.0/8) on all interfaces"
info " - Only allows MDM traffic through VPN interface ($vpn_if)"
info " - If VPN drops, MDM traffic is blocked — no leaks"
echo ""
warn "This does NOT affect your regular internet traffic."
warn "Only MDM-related IPs are routed through the VPN kill-switch."
}
vpn_kill_remove() {
header "Remove VPN Kill-Switch"
if ! is_root; then
error_exit "Needs sudo: sudo ./runaway vpn-kill-remove"
fi
if [ -f "$VPN_RULES_FILE" ]; then
rm -f "$VPN_RULES_FILE"
success "VPN kill-switch rules removed"
fi
local pf_conf="/etc/pf.conf"
if [ -f "$pf_conf" ]; then
sed -i '' '/# Added by runaway — VPN kill-switch/d' "$pf_conf" 2>/dev/null || true
sed -i '' '/vpn-kill/d' "$pf_conf" 2>/dev/null || true
success "pf.conf cleaned"
fi
pfctl -a "$VPN_RULES_ANCHOR" -F all 2>/dev/null || true
success "pf anchor flushed"
}
vpn_kill_status() {
step "VPN kill-switch status"
if [ -f "$VPN_RULES_FILE" ]; then
echo " Rules file: $VPN_RULES_FILE"
cat "$VPN_RULES_FILE" | sed 's/^/ /'
else
echo " No VPN kill-switch installed"
fi
if command -v pfctl &>/dev/null; then
echo ""
pfctl -a "$VPN_RULES_ANCHOR" -s rules 2>/dev/null \
&& echo " Anchor loaded" \
|| echo " Anchor not loaded"
fi
}
show_cmd_help() {
case "$1" in
bypass) echo "Bypass MDM from Recovery. Creates admin user." ;;
suppress) echo "Suppress enrollment without creating a user." ;;
admin) echo "Create an admin user without suppressing enrollment." ;;
heal) echo "Re-apply suppression after macOS updates." ;;
persist) echo "Install auto-heal LaunchDaemon." ;;
unpersist) echo "Remove auto-heal LaunchDaemon." ;;
firewall) echo "Block MDM IPs via pf (kernel-level). DoH-proof." ;;
firewall-off) echo "Remove pf MDM block." ;;
harden) echo "Kill MDM processes + remove profiles + flush DNS." ;;
audit) echo "Deep system scan with risk score." ;;
whitelist) echo "Block only MDM domains, keep iCloud/App Store." ;;
backup) echo "Save current state." ;;
restore) echo "Restore from backup." ;;
dualboot) echo "Target an external macOS install." ;;
status) echo "Show MDM enrollment status (Recovery only)." ;;
check) echo "Pre-format / pre-upgrade safety report." ;;
history) echo "Show event log from monitor/heal runs." ;;
history-clear) echo "Clear event log." ;;
monitor) echo "Start background MDM monitor (5 min interval)." ;;
monitor-install) echo "Install monitor as LaunchDaemon." ;;
monitor-uninstall) echo "Remove monitor LaunchDaemon." ;;
monitor-stop) echo "Stop the monitor daemon." ;;
monitor-status) echo "Check if monitor is running." ;;
doctor) echo "Run pre-flight diagnostics; --network reports the build and Wi-Fi state." ;;
init) echo "Interactive setup wizard." ;;
suggest) echo "Risk-based recommendations." ;;
remediate) echo "Per-org MDM cleanup." ;;
predict) echo "Look up serial number enrollment." ;;
telemetry) echo "Manage anonymous usage stats (opt-in)." ;;
discord-bot) echo "Start Discord MDM alert bot." ;;
discord-bot-stop) echo "Stop Discord bot." ;;
discord-bot-status) echo "Check Discord bot status." ;;
demo) echo "Simulated bypass flow (no changes)." ;;
update) echo "Self-update from GitHub releases." ;;
uninstall) echo "Remove all Runaway traces." ;;
reinstall) echo "Uninstall + clean install." ;;
report) echo "Generate full status report (markdown or --json)." ;;
config) echo "View/edit ~/.runaway.conf settings." ;;
vpn-kill) echo "Install pf kill-switch (blocks MDM outside VPN)." ;;
vpn-kill-remove) echo "Remove VPN kill-switch." ;;
vpn-kill-status) echo "Check VPN kill-switch status." ;;
version) echo "Show version and exit." ;;
help) show_help ;;
*) show_help ;;
esac
}
show_help() {
cat <<'HELP'
Usage: ./runaway <command> [options]
Bypass / suppress / monitor MDM enrollment on macOS.
COMMANDS
Core:
bypass Full MDM bypass from Recovery (creates admin user)
suppress Silence enrollment, no user created
admin Create a local admin user without suppressing enrollment
heal Check + re-apply suppression after macOS updates
Persistence:
persist Install LaunchDaemon (auto-heal on every boot)
unpersist Remove the persistence LaunchDaemon
Firewall:
firewall Block Apple MDM at kernel level via pf
firewall-off Remove pf rules
whitelist Block only MDM endpoints, keep iCloud/App Store
Living System:
harden Kill MDM processes + remove profiles + flush DNS
audit Deep system scan with risk score
Monitoring:
check Pre-format / pre-upgrade safety report
history Show event log from monitor/heal runs
test Dry-run mode: simulate without changing anything
monitor Background daemon (watches MDM every 5 min)
monitor-install Install monitor as LaunchDaemon (boot persistent)
monitor-uninstall Remove monitor LaunchDaemon
monitor-stop Stop the daemon
monitor-status Check if daemon is running
State:
backup Save hosts, profiles, launchd state
restore Revert from backup
dualboot Target an external macOS install
init Interactive setup wizard
suggest Risk-based recommendations
remediate Per-org MDM cleanup
predict Look up serial number enrollment
telemetry Manage anonymous usage stats (opt-in)
Diagnostics:
doctor Run pre-flight checks on this environment
report Generate a full markdown status report
history Show event log from monitor/heal runs
test Dry-run mode: simulate without changing anything
demo Run simulated bypass flow (no real changes)
VPN:
vpn-kill Install VPN kill-switch (prevents MDM leaks outside VPN)
vpn-kill-remove Remove VPN kill-switch
vpn-kill-status Check VPN kill-switch status
Management:
config View/edit persistent settings (~/.runaway.conf)
update Self-update to the latest GitHub release
uninstall Remove all Runaway traces from the system
reinstall Uninstall + reinstall (persist + whitelist + monitor)
discord-bot Start Discord MDM alert bot
discord-bot-stop Stop Discord bot
discord-bot-status Check Discord bot status
Info:
status Show MDM enrollment status (Recovery only)
version Show version
help This message
ALIASES
st status
ls status
fw firewall
fw-off firewall-off
wl whitelist
sv suppress
by bypass
adm admin
mn monitor
mn-install monitor-install
mn-uninstall monitor-uninstall
mn-stop monitor-stop
mn-st monitor-status
doc doctor
up update
uni uninstall
rei reinstall
vk vpn-kill
vkr vpn-kill-remove
vks vpn-kill-status
OPTIONS
--verbose Show debug messages
--dry-run Simulate without making changes
--log-file <f> Write logs to file (appended)
Run without arguments for interactive menu.
HELP
}
cmd_version() {
echo "runaway v$VERSION"
exit 0
}
cmd_bypass() {
if is_recovery; then
if [ "$DRY_RUN" = true ]; then
full_bypass_mode "the selected Data volume"
return
fi
header "Full MDM Bypass"
local data_mount
data_mount=$(resolve_data_volume)
full_bypass_mode "$data_mount"
else
error_exit "Full bypass must run from Recovery mode."
fi
}
cmd_suppress() {
if [ "$DRY_RUN" = true ]; then
suppress_only_mode "the selected Data volume"
return
fi
header "Suppress Enrollment"
local data_mount
data_mount=$(resolve_data_volume)
suppress_only_mode "$data_mount"
}
cmd_admin() {
if ! is_recovery; then
error_exit "Admin creation must run from Recovery mode."
fi
if [ "$DRY_RUN" = true ]; then
admin_only_mode "the selected Data volume"
return
fi
header "Create Local Admin User"
local data_mount
data_mount=$(resolve_data_volume)
admin_only_mode "$data_mount"
}
cmd_backup() {
header "Backup"
local data_mount
data_mount=$(resolve_data_volume)
backup_state "$data_mount"
}
cmd_restore() {
header "Restore"
restore_state
}
cmd_dualboot() {
if [ "$DRY_RUN" = true ]; then
info "[DRY RUN] Would select an external macOS installation and create an admin account."
info "[DRY RUN] Would update its hosts file and enrollment markers."
return 0
fi
if ! is_root; then
error_exit "Dual-boot needs sudo: sudo ./runaway dualboot"
fi
header "Dual-Boot Mode"
local volumes
volumes=$(resolve_target_volumes)
local sys_path="${volumes%%|*}"
local data_path="${volumes##*|}"
info "Target system: $sys_path"
info "Target data: $data_path"
local node
node=$(dscl_node "$data_path")
echo ""
step "Creating admin account on target"
local realName
prompt_default realName "Full name" "Apple"
local username
prompt_username username
local passw
prompt_password passw
local uid
uid=$(find_available_uid "$node")
create_admin_user "$node" "$data_path" "$username" "$realName" "$passw" "$uid"
touch "$data_path/private/var/db/.AppleSetupDone"
begin "Blocking domains"
local hosts_file="$data_path/private/etc/hosts"
[ -f "$hosts_file" ] || touch "$hosts_file"
printf '%s\n' "0.0.0.0 deviceenrollment.apple.com" "0.0.0.0 mdmenrollment.apple.com" "0.0.0.0 iprofiles.apple.com" >>"$hosts_file"
end_ok
begin "Resetting config profiles"
local config_path="$data_path/private/var/db/ConfigurationProfiles/Settings"
mkdir -p "$config_path"
rm -f "$config_path/.cloudConfigHasActivationRecord" \
"$config_path/.cloudConfigRecordFound"
touch "$config_path/.cloudConfigProfileInstalled" \
"$config_path/.cloudConfigRecordNotFound"
end_ok
info "User: $username"
info "Log in with the password entered above."
info "Boot the target and login."
}
cmd_heal() {
if is_recovery; then
local data_mount
data_mount=$(resolve_data_volume)
heal_suppress "$data_mount"
else
if ! is_root; then
error_exit "Heal needs sudo: sudo ./runaway heal"
fi
heal_suppress ""
fi
}
cmd_persist() {
local data_mount
if is_recovery; then
data_mount=$(resolve_data_volume)
else
if ! is_root; then
error_exit "Persistence needs sudo: sudo ./runaway persist"
fi
data_mount=""
fi
install_persist_launchdaemon "$data_mount"
}
cmd_unpersist() {
local data_mount
if is_recovery; then
data_mount=$(resolve_data_volume)
else
data_mount=""
fi
remove_persist_launchdaemon "$data_mount"
}
cmd_firewall() {
if ! is_root; then
error_exit "Firewall needs sudo: sudo ./runaway firewall"
fi
if is_recovery; then
local data_mount
data_mount=$(resolve_data_volume)
install_pf_mdm_block "$data_mount"
else
install_pf_mdm_block ""
fi
}
cmd_firewall_off() {
if ! is_root; then
error_exit "Needs sudo: sudo ./runaway firewall-off"
fi
if is_recovery; then
local data_mount
data_mount=$(resolve_data_volume)
remove_pf_mdm_block "$data_mount"
else
remove_pf_mdm_block ""
fi
}
cmd_harden() {
if ! is_root; then
error_exit "Hardening needs sudo: sudo ./runaway harden"
fi
if is_recovery; then
info "In Recovery — will skip live-OS checks"
fi
harden_live_os
}
cmd_audit() {
if ! is_root; then
error_exit "Audit needs sudo: sudo ./runaway audit"
fi
deep_status
}
cmd_whitelist() {
if ! is_root; then
error_exit "Whitelist needs sudo: sudo ./runaway whitelist"
fi
if is_recovery; then
local data_mount
data_mount=$(resolve_data_volume)
install_selective_block "$data_mount"
else
install_selective_block ""
fi
}
cmd_status() {
if is_recovery; then
local data_mount
data_mount=$(resolve_data_volume)
check_mdm_status "$data_mount"
else
error_exit "Status works from Recovery. Try 'check' or 'audit' instead."
fi
}
cmd_check() {
if ! is_root; then
error_exit "Check needs sudo: sudo ./runaway check"
fi
run_preformat_check
echo ""
check_upgrade_safety
}
cmd_monitor() {
local webhook=""
local args=()
while [ $# -gt 0 ]; do
case "$1" in
install|uninstall) args+=("$1"); shift ;;
--webhook)
if [ $# -lt 2 ] || [ -z "$2" ]; then error_exit "--webhook requires a URL"; fi
webhook="$2"; shift 2 ;;
*) args+=("$1"); shift ;;
esac
done
set -- "${args[@]}"
if [ -n "$webhook" ]; then
DISCORD_WEBHOOK="$webhook"
fi
case "${1:-}" in
install) install_monitor_launchdaemon "" ;;
uninstall) uninstall_monitor_launchdaemon "" ;;
*) monitor_mdm ;;
esac
}
cmd_monitor_stop() { stop_monitor; }
cmd_monitor_status() { monitor_status; }
cmd_history() { show_history; }
cmd_history_clear() { clear_history; }
cmd_test() {
header "Dry Run Mode"
DRY_RUN=true
local cmd="${2:-suppress}"
case "$cmd" in
bypass) info "Simulating: bypass"; cmd_bypass ;;
suppress) info "Simulating: suppress"; cmd_suppress ;;
heal) info "Simulating: heal"; cmd_heal ;;
harden) info "Simulating: harden"; cmd_harden ;;
firewall) info "Simulating: firewall"; cmd_firewall ;;
whitelist) info "Simulating: whitelist"; cmd_whitelist ;;
all)
info "Simulating all available operations..."
info ""
DRY_RUN=true suppress_enrollment "/"
info ""
DRY_RUN=true full_bypass_mode "/"
info ""
info "Dry-run complete. No changes were made."
;;
*) info "Usage: ./runaway test {bypass|suppress|heal|harden|firewall|whitelist|all}" ;;
esac
}
cmd_interactive_recovery() {
header "runaway"
local data_mount
data_mount=$(resolve_data_volume)
echo ""
PS3="Choose: "
local options=(
"Full bypass (create admin + suppress MDM)"
"Suppress enrollment only"
"Create local admin user only"
"Auto-heal"
"Install pf firewall"
"Remove pf firewall"
"Install selective block (iCloud-safe)"
"Live-OS harden"
"Deep MDM audit"
"Backup state"
"Restore from backup"
"Check MDM status"
"Pre-format check"
"Reboot"
"Exit"
)
select opt in "${options[@]}"; do
case $opt in
"Full bypass (create admin + suppress MDM)")
full_bypass_mode "$data_mount"
info "Reboot to apply."
;;
"Suppress enrollment only")
suppress_only_mode "$data_mount"
;;
"Create local admin user only")
admin_only_mode "$data_mount"
;;
"Auto-heal")
heal_suppress "$data_mount"
;;
"Install pf firewall")
install_pf_mdm_block "$data_mount"
;;
"Remove pf firewall")
remove_pf_mdm_block "$data_mount"
;;
"Install selective block (iCloud-safe)")
install_selective_block "$data_mount"
;;
"Live-OS harden")
harden_live_os
;;
"Deep MDM audit")
deep_status
;;
"Backup state")
backup_state "$data_mount"
;;
"Restore from backup")
restore_state
;;
"Check MDM status")
check_mdm_status "$data_mount"
;;
"Pre-format check")
run_preformat_check
;;
"Reboot")
info "Rebooting..."
reboot
;;
"Exit")
exit 0
;;
*)
echo -e "${RED}Invalid option $REPLY${NC}"
;;
esac
done
}
cmd_interactive_normal() {
header "runaway"
echo -e "${YEL}Not in Recovery. Limited options.${NC}"
echo " Try: sudo ./runaway heal | harden | audit | check | monitor"
echo ""
PS3="Choose: "
local options=(
"Auto-heal"
"Backup state"
"Restore from backup"
"Exit"
)
select opt in "${options[@]}"; do
case $opt in
"Auto-heal")
if ! is_root; then
error_exit "Heal needs sudo. Run: sudo ./runaway"
fi
heal_suppress ""
;;
"Backup state")
local data_mount
data_mount=$(resolve_data_volume)
backup_state "$data_mount"
;;
"Restore from backup")
restore_state
;;
"Exit")
exit 0
;;
*)
echo -e "${RED}Invalid $REPLY${NC}"
;;
esac
done
}
parse_global_opts() {
PARSED_ARGS=()
while [ $# -gt 0 ]; do
case "$1" in
--verbose) VERBOSE=true; shift ;;
--dry-run) DRY_RUN=true; shift ;;
--log-file)
if [ $# -lt 2 ] || [ -z "$2" ]; then error_exit "--log-file requires a path"; fi
case "$2" in --*) error_exit "--log-file requires a path" ;; esac
LOG_FILE="$2"; shift 2 ;;
--) shift; PARSED_ARGS+=("$@"); break ;;
*) PARSED_ARGS+=("$1"); shift ;;
esac
done
}
main() {
load_config
parse_global_opts "$@"
if [ "${PARSED_ARGS[0]+present}" = present ]; then
set -- "${PARSED_ARGS[@]}"
else
set --
fi
# Per-command help
if [ "${2:-}" = "--help" ] || [ "${2:-}" = "-h" ]; then
show_cmd_help "${1:-}"
exit 0
fi
case "${1:-}" in
bypass|by) cmd_bypass ;;
suppress|sv) cmd_suppress ;;
admin|adm) cmd_admin ;;
heal) cmd_heal ;;
persist) cmd_persist ;;
unpersist) cmd_unpersist ;;
firewall|fw) cmd_firewall ;;
firewall-off|fw-off) cmd_firewall_off ;;
harden) cmd_harden ;;
audit) cmd_audit "${2:-}" ;;
whitelist|wl) cmd_whitelist ;;
backup) cmd_backup ;;
restore) cmd_restore ;;
dualboot) cmd_dualboot ;;
status|st|ls) cmd_status ;;
check) cmd_check ;;
history) cmd_history ;;
history-clear) cmd_history_clear ;;
test|dry-run) cmd_test "$@" ;;
monitor|mn) cmd_monitor "$@" ;;
monitor-install|mn-install) install_monitor_launchdaemon "" ;;
monitor-uninstall|mn-uninstall) uninstall_monitor_launchdaemon "" ;;
monitor-stop|mn-stop) cmd_monitor_stop ;;
monitor-status|mn-st) cmd_monitor_status ;;
doctor) run_doctor "${2:-}" ;;
version|-v|--version) cmd_version ;;
init) cmd_init ;;
suggest) cmd_suggest ;;
remediate) cmd_remediate "${2:-}" ;;
predict) cmd_predict "${2:-}" ;;
telemetry) telemetry_opt_in "${2:-}" ;;
demo) run_demo ;;
update) do_self_update ;;
uninstall) do_uninstall ;;
report) generate_report "${2:-}" ;;
config) cmd_config "$@" ;;
vpn-kill) vpn_kill_install "$@" ;;
vpn-kill-remove) vpn_kill_remove ;;
vpn-kill-status) vpn_kill_status ;;
reinstall)
do_uninstall
install_persist_launchdaemon ""
install_selective_block ""
install_monitor_launchdaemon ""
success "Reinstall complete"
;;
discord-bot) cmd_discord_bot_install "${2:-}" "${3:-}" ;;
discord-bot-stop) cmd_discord_bot_stop ;;
discord-bot-status) cmd_discord_bot_status ;;
help|-h|--help) show_help; exit 0 ;;
"")
if is_recovery; then
cmd_interactive_recovery
else
cmd_interactive_normal
fi
;;
*)
echo -e "${RED}Unknown: $1${NC}" >&2
show_help >&2
exit 1
;;
esac
}
main "$@"