Files
notfiles/scripts/tests/test_make_usb.sh
T

390 lines
14 KiB
Bash
Executable File

#!/usr/bin/env bash
set -u
# shellcheck source=harness.sh
source "$(dirname "$0")/harness.sh"
export SCRIPTS
MU="$SCRIPTS/make-usb.sh"
DRIVER="$HARNESS_DIR/usb_driver.sh"
# ---- fixtures --------------------------------------------------------------
TAB=$'\t'
row() { printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$@" >> "$FAKE_DISKS"; }
mkfix() {
export PATH="$SHIMS:$PATH"
export FAKE_DISKS="$T/disks.tsv" FAKE_MOUNTS="$T/mounts" FAKE_OPS_LOG="$T/ops.log" PROC_SWAPS="$T/swaps"
mkdir -p "$T/dev" "$T/iso"
: > "$FAKE_DISKS"; : > "$FAKE_MOUNTS"; : > "$FAKE_OPS_LOG"
printf 'Filename\tType\tSize\tUsed\tPriority\n' > "$PROC_SWAPS"
SDA="$T/dev/sda" SDB="$T/dev/sdb" SDC="$T/dev/sdc" SDD="$T/dev/sdd"
touch "$SDA" "$SDC" "$SDD"; truncate -s 16M "$SDB"
# name type size model tran rm children
row "$SDA" disk 500107862016 "Samsung SSD 860" sata 0 "${SDA}1,${SDA}2,${SDA}3"
row "$SDB" disk 16008609792 "SanDisk Ultra" usb 1 "${SDB}1"
row "$SDC" disk 1000204886016 "WD Elements" usb 0 "${SDC}1"
row "$SDD" disk 250059350016 "Data SSD" sata 0 "${SDD}1"
row "$T/dev/sr0" rom 1073741312 "DVD" sata 1 -
row "$T/dev/loop0" loop 1000000 - - 0 -
printf '%s /\n%s /boot/efi\n%s /run/media/alex/NIXOS\n' "${SDA}2" "${SDA}1" "${SDB}1" > "$FAKE_MOUNTS"
ISO="$T/iso/nixos.iso"; head -c 3145728 /dev/urandom > "$ISO"
(cd "$T/iso" && sha256sum nixos.iso > nixos.iso.sha256)
}
ops() { cat "$FAKE_OPS_LOG"; }
did() { grep -q -- "$1" "$FAKE_OPS_LOG"; }
usb() { run bash "$DRIVER" "$@"; } # non-interactive end-to-end
unit() { run bash -c 'source "$SCRIPTS/make-usb.sh"; is_block_device() { [[ -e "$1" ]]; }; set +e; '"$1"; }
# pty(): run the driver on a pseudo-terminal feeding $1 as keyboard input.
pty() { local input="$1"; shift; local cmd; cmd="$(printf '%q ' bash "$DRIVER" "$@")"
local o="$T/pty.out"; printf '%b' "$input" | script -qec "$cmd" /dev/null > "$o" 2>&1; RC=$?; OUT="$(<"$o")"; ERR="$OUT"; }
# ---- unit: device inspection ----------------------------------------------
test_model_strings_cannot_inject_commands() {
mkfix
# The old script ran `eval` on lsblk output, so a USB stick whose model is
# "$(touch PWNED)" executed arbitrary commands as root.
row "$T/dev/sde" disk 16008609792 "\$(touch $T/PWNED) \`touch $T/PWNED2\` \"; touch $T/PWNED3; \"" usb 1 -
touch "$T/dev/sde"
pty "0\n" ; unit 'select_device <<<"0" 2>&1; echo done'
pty "0\n"
assert_no_path "$T/PWNED"; assert_no_path "$T/PWNED2"; assert_no_path "$T/PWNED3"
[[ "$OUT" == *'touch'* ]] || _fail "malicious model should be displayed as inert text: $OUT"
}
test_original_script_was_exploitable_via_model_string() {
# Documents the vulnerability being fixed: this is the original parsing logic.
local line='NAME="/dev/sdx" MODEL="$(touch '"$T"'/PWNED)" TYPE="disk"'
[[ "$line" =~ ^([A-Z]+=\"[^\"]*\"[[:space:]]*)+$ ]] || _fail "original validation regex would have rejected it"
eval "$line"
assert_file "$T/PWNED"
}
test_blk_field_strips_control_characters() {
mkfix
row "$T/dev/sdf" disk 1 $'\e[31mEVIL\e[0m\a\r ' usb 1 -
unit "blk_field '$T/dev/sdf' MODEL | cat -v"
assert_eq '[31mEVIL[0m' "$OUT"
unit "blk_field '$SDB' MODEL"; assert_eq "SanDisk Ultra" "$OUT"
}
test_list_candidates_skips_optical_and_loop() {
mkfix
unit 'list_candidate_disks'
assert_eq "$SDA
$SDB
$SDC
$SDD" "$OUT"
}
test_protected_mounts_allowlist_not_blocklist() {
mkfix
# The old check only looked for exactly / and /boot, so these slipped through:
printf '%s /nix/store\n%s /home\n%s /var/lib/docker\n%s /boot/efi\n' "${SDD}1" "${SDD}1" "${SDD}1" "${SDD}1" > "$FAKE_MOUNTS"
unit "protected_mounts '$SDD'"
assert_eq "/nix/store
/home
/var/lib/docker
/boot/efi" "$OUT"
}
test_automount_points_are_not_protected() {
mkfix
printf '%s /run/media/alex/A B\n%s /media/usb\n%s /mnt/x\n' "${SDB}1" "${SDB}1" "${SDB}1" > "$FAKE_MOUNTS"
unit "protected_mounts '$SDB'; echo rc=\$?"
assert_eq "rc=0" "$OUT"
}
test_mount_point_with_spaces_decoded() {
mkfix
printf '%s /run/media/alex/My\\x20Stick\n' "${SDB}1" > "$FAKE_MOUNTS"
unit "mounts_of '$SDB'"
assert_eq "/run/media/alex/My Stick" "$OUT"
}
test_btrfs_subvolume_suffix_and_luks_holder() {
mkfix
row "$T/dev/sdg" disk 1000000000000 "NVMe" nvme 0 "$T/dev/sdg1,$T/dev/mapper/cryptroot"
printf '%s[/@] /\n%s /home\n' "$T/dev/mapper/cryptroot" "$T/dev/mapper/cryptroot" > "$FAKE_MOUNTS"
touch "$T/dev/sdg"
unit "protected_mounts '$T/dev/sdg'"
assert_eq "/
/home" "$OUT"
}
test_swap_protects_disk() {
mkfix
printf '%s\tpartition\t100\t0\t-2\n' "${SDD}1" >> "$PROC_SWAPS"
unit "protected_mounts '$SDD'"
assert_out_has "SWAP"
}
test_unreadable_swap_table_fails_closed() {
mkfix
PROC_SWAPS="$T/does-not-exist" unit "protected_mounts '$SDB'"
assert_out_has "SWAP"
}
test_unreadable_mount_table_fails_closed() {
mkfix
FAKE_FINDMNT_FAIL=1 unit "protected_mounts '$SDB'"
assert_out_has "mount table unreadable"
FAKE_FINDMNT_FAIL=1 unit "unsafe_reason '$SDB'; echo rc=\$?"
assert_out_has "rc=0" # 0 means "unsafe"
}
test_lsblk_failure_fails_closed() {
mkfix
FAKE_LSBLK_FAIL=1 unit "unsafe_reason '$SDB'; echo rc=\$?"
assert_out_has "cannot inspect"; assert_out_has "rc=0"
}
test_unsafe_reason_matrix() {
mkfix
local d expect
# device : expected verdict ("safe" or substring of the reason)
for pair in "$SDB:safe" "$SDC:safe" "$SDA:in-use system data" "$SDD:neither removable" \
"${SDB}1:not a whole disk" "$T/dev/nonexistent:not a block device"; do
d="${pair%%:*}"; expect="${pair#*:}"
# `${SDB}1` is a child and is not a node in the fixture: create it so is_block_device passes.
touch "$d" 2>/dev/null
unit "unsafe_reason '$d'; echo rc=\$?" ; [[ "$d" == *nonexistent ]] && rm -f "$d" && unit "unsafe_reason '$d'; echo rc=\$?"
if [[ "$expect" == safe ]]; then
assert_eq "rc=1" "$OUT" "$d should be acceptable"
else
[[ "$OUT" == *"$expect"* && "$OUT" == *rc=0 ]] || _fail "$d: wanted '$expect', got: $OUT"
fi
done
}
test_usb_hdd_reporting_removable_0_is_accepted_via_transport() {
mkfix
printf '' > "$FAKE_MOUNTS"
row "$T/dev/sdh" disk 1000204886016 "Passport" usb 0 -
touch "$T/dev/sdh"
unit "unsafe_reason '$T/dev/sdh'; echo rc=\$?"; assert_eq "rc=1" "$OUT"
}
test_allow_internal_does_not_override_system_disk() {
mkfix
unit "ALLOW_INTERNAL=1; unsafe_reason '$SDD'; echo rc=\$?"; assert_eq "rc=1" "$OUT" # data disk: now allowed
unit "ALLOW_INTERNAL=1; unsafe_reason '$SDA'; echo rc=\$?"; assert_out_has "in-use system data"
}
test_iso_on_target_device_detected() {
mkfix
printf '%s /run/media/alex/NIXOS\n' "${SDB}1" > "$FAKE_MOUNTS"
unit "iso_on_device /run/media/alex/NIXOS/nixos.iso '$SDB'; echo rc=\$?"; assert_eq "rc=0" "$OUT"
unit "iso_on_device /run/media/alex/NIXOS/nixos.iso '$SDD'; echo rc=\$?"; assert_eq "rc=1" "$OUT"
printf '%s /\n' "${SDA}2" > "$FAKE_MOUNTS"
unit "iso_on_device /home/alex/nixos.iso '$SDB'; echo rc=\$?"; assert_eq "rc=1" "$OUT"
}
# ---- end to end -------------------------------------------------------------
test_e2e_happy_path() {
mkfix
usb --iso "$ISO" --device "$SDB" --yes
assert_rc 0
assert_err_has "Read-back verified"
cmp -n 3145728 "$ISO" "$SDB" || _fail "device content differs from ISO"
did "umount /run/media/alex/NIXOS" || _fail "stick was not unmounted: $(ops)"
did "wipefs -a $SDB" || _fail "no wipefs"
# order matters: unmount -> wipe -> dd
local order; order="$(grep -o '^\(umount\|wipefs\|dd\)' "$FAKE_OPS_LOG" | tr '\n' ' ')"
assert_eq "umount wipefs dd " "$order"
}
test_e2e_resolves_symlinked_device_path() {
mkfix
mkdir -p "$T/dev/disk/by-id"; ln -s "$SDB" "$T/dev/disk/by-id/usb-SanDisk"
usb --iso "$ISO" --device "$T/dev/disk/by-id/usb-SanDisk" --yes
assert_rc 0
cmp -n 3145728 "$ISO" "$SDB" || _fail "wrote to wrong target"
}
test_e2e_refuses_system_disk_and_writes_nothing() {
mkfix
usb --iso "$ISO" --device "$SDA" --yes --allow-internal
assert_rc 4; assert_err_has "in-use system data"
! did "dd " && ! did wipefs && ! did umount || _fail "touched the system disk: $(ops)"
}
test_e2e_refuses_partition() {
mkfix; touch "${SDB}1"
usb --iso "$ISO" --device "${SDB}1" --yes
assert_rc 4
! did "dd " || _fail "wrote to a partition"
}
test_e2e_refuses_internal_without_flag() {
mkfix
usb --iso "$ISO" --device "$SDD" --yes
assert_rc 4; assert_err_has "--allow-internal"
usb --iso "$ISO" --device "$SDD" --yes --allow-internal
assert_rc 0
}
test_e2e_refuses_when_iso_is_on_target() {
mkfix
# A realistic desktop auto-mount: the stick is mounted under /run/media and
# the ISO sits on it. Wiping the stick would destroy the very file we are
# about to write.
local mnt="/run/media/mkusb-test-$$/NIXOS"
mkdir -p "$mnt" 2>/dev/null || { echo " (skipped: cannot create /run/media; needs root)"; return 0; }
cp "$ISO" "$mnt/nixos.iso"
printf '%s %s\n%s /\n' "${SDB}1" "$mnt" "${SDA}2" > "$FAKE_MOUNTS"
usb --iso "$mnt/nixos.iso" --device "$SDB" --yes
local rc=$RC err="$ERR"; rm -rf "/run/media/mkusb-test-$$"
RC=$rc ERR="$err"
assert_rc 4; assert_err_has "stored on"
! did "dd " && ! did wipefs && ! did umount || _fail "touched the disk holding the ISO: $(ops)"
}
test_e2e_iso_bigger_than_disk() {
mkfix
row "$T/dev/sdt" disk 1000 "Tiny" usb 1 -; touch "$T/dev/sdt"
usb --iso "$ISO" --device "$T/dev/sdt" --yes
assert_rc 4; assert_err_has "larger than the disk"
}
test_e2e_empty_or_missing_iso() {
mkfix
: > "$T/empty.iso"
usb --iso "$T/empty.iso" --device "$SDB" --yes; assert_rc 4; assert_err_has "empty"
usb --iso "$T/nope.iso" --device "$SDB" --yes; assert_rc 4; assert_err_has "not found"
! did "dd " || _fail "dd ran"
}
test_e2e_checksum_mismatch_blocks_write() {
mkfix
echo "$(printf '%064d' 0) nixos.iso" > "$T/iso/nixos.iso.sha256"
usb --iso "$ISO" --device "$SDB" --yes
assert_rc 5; assert_err_has "sha256 verification failed"
! did "dd " && ! did wipefs || _fail "wrote despite bad checksum"
}
test_e2e_checksum_sidecar_found_via_symlink() {
mkfix
ln -s "$ISO" "$T/iso/latest.iso"
echo "$(printf '%064d' 0) nixos.iso" > "$T/iso/nixos.iso.sha256"
usb --iso "$T/iso/latest.iso" --device "$SDB" --yes
assert_rc 5 # mismatch detected through the symlink
}
test_e2e_missing_sidecar_warns_but_proceeds() {
mkfix; rm "$T/iso/nixos.iso.sha256"
usb --iso "$ISO" --device "$SDB" --yes
assert_rc 0; assert_err_has "skipping checksum"
}
test_e2e_corrupted_write_detected() {
mkfix
FAKE_DD_CORRUPT=1 usb --iso "$ISO" --device "$SDB" --yes
assert_rc 6; assert_err_has "verification FAILED"
}
test_e2e_no_verify_flag_skips_readback() {
mkfix
FAKE_DD_CORRUPT=1 usb --iso "$ISO" --device "$SDB" --yes --no-verify
assert_rc 0; assert_err_has "skipping read-back"
}
test_e2e_dd_failure_reports_kernel_messages() {
mkfix
FAKE_DD_FAIL=1 FAKE_DMESG="[ 12.3] sdb: Medium Error, sector 42" usb --iso "$ISO" --device "$SDB" --yes
assert_rc 5; assert_err_has "dd failed"; assert_err_has "Medium Error"
assert_err_lacks "Read-back verified"
}
test_e2e_dd_failure_without_kernel_messages_hints_dmesg() {
mkfix
FAKE_DD_FAIL=1 usb --iso "$ISO" --device "$SDB" --yes
assert_rc 5; assert_err_has "dmesg"
}
test_e2e_unmount_failure_aborts_before_any_write() {
mkfix
FAKE_UMOUNT_FAIL="/run/media/alex/NIXOS" usb --iso "$ISO" --device "$SDB" --yes
assert_rc 4; assert_err_has "could not unmount"
! did "dd " && ! did wipefs || _fail "wrote to a busy device: $(ops)"
! did "umount -l" || _fail "used lazy unmount"
}
test_e2e_noninteractive_requires_all_args() {
mkfix
usb --iso "$ISO" --device "$SDB" # no --yes
assert_rc 2; assert_err_has "not a tty"
usb --device "$SDB" --yes
assert_rc 2
! did "dd " || _fail "dd ran"
}
test_e2e_argument_errors() {
mkfix
usb --bogus; assert_rc 2
usb --iso; assert_rc 2; assert_err_has "requires a value"
usb --device; assert_rc 2
usb -h; assert_rc 0; assert_out_has "Usage:"
}
test_e2e_equals_form() {
mkfix
usb --iso="$ISO" --device="$SDB" --yes
assert_rc 0
}
test_e2e_missing_tools() {
mkfix
local bin="$T/bin"; mkdir -p "$bin"
local c; for c in bash dirname readlink env cat sed grep tr awk stat dd sync blockdev umount wipefs findmnt; do ln -s "$(command -v "$c")" "$bin/$c" 2>/dev/null; done
# no lsblk
PATH="$bin" run bash "$DRIVER" --iso "$ISO" --device "$SDB" --yes
assert_rc 3; assert_err_has "lsblk"
}
# ---- interactive (pty) ------------------------------------------------------
test_pty_menu_marks_system_disk_and_rejects_bad_input() {
mkfix
# abc -> not a number; 99 -> out of range; 08 -> must not crash on octal; 1 (=sda, system) -> refused; 0 -> abort
pty 'abc\n99\n08\n1\n0\n' --iso "$ISO" --yes
assert_rc 1
[[ "$OUT" == *"not a number"* ]] || _fail "no 'not a number': $OUT"
[[ "$OUT" == *"out of range"* ]] || _fail "no 'out of range'"
[[ "$OUT" == *"value too great for base"* ]] && _fail "octal crash on '08'"
[[ "$OUT" == *"SYSTEM DISK"* ]] || _fail "system disk not flagged"
[[ "$OUT" == *"in-use system data"* ]] || _fail "selecting the system disk was not refused"
! did "dd " || _fail "dd ran"
}
test_pty_eof_in_menu_is_a_clean_error() {
mkfix
pty '' --iso "$ISO" --yes
assert_rc 1
}
test_pty_select_and_typed_confirmation() {
mkfix
printf '' > "$FAKE_MOUNTS" # nothing mounted: only the stick matters
# menu order: sda sdb sdc sdd -> 2 is the SanDisk
pty "2\n$SDB\n" --iso "$ISO"
assert_rc 0
cmp -n 3145728 "$ISO" "$SDB" || _fail "not written"
}
test_pty_wrong_confirmation_aborts_without_writing() {
mkfix
pty "2\n$SDC\n" --iso "$ISO"
assert_rc 1
[[ "$OUT" == *"confirmation didn't match"* ]] || _fail "$OUT"
! did "dd " && ! did wipefs && ! did umount || _fail "acted despite wrong confirmation"
}
test_pty_prompts_for_iso_and_expands_tilde() {
mkfix
printf '' > "$FAKE_MOUNTS"
export HOME="$T/home"; mkdir -p "$HOME"; cp "$ISO" "$HOME/my.iso"
pty "~/my.iso\n" --device "$SDB" --yes
assert_rc 0
cmp -n 3145728 "$ISO" "$SDB" || _fail "wrong ISO written"
}
run_all "${1:-}"