CLI for SidePulse
Python
"""Exercise raw-disk safety entirely in memory; never open a real device."""
import contextlib
import plistlib
import stat
import struct
import unittest
from types import SimpleNamespace
from unittest.mock import patch
from scripts import write_led_raw as raw
def fat12_image(cluster=2, entry_index=0, spc=1):
image = bytearray(340 * 512)
struct.pack_into("<HBHBHH", image, 11, 512, spc, 1, 1, 32, 340)
struct.pack_into("<H", image, 22, 1)
image[510:512] = b"\x55\xaa"
image[512:515] = b"\xf8\xff\xff"
struct.pack_into("<H", image, 512 + cluster + cluster // 2,
0xFFF << (4 if cluster & 1 else 0))
for i in range(entry_index):
image[1024 + i * 32] = 0xE5
entry = 1024 + entry_index * 32
image[entry:entry + 11] = b"LEDS LED"
image[entry + 11] = 0x20
struct.pack_into("<H", image, entry + 26, cluster)
struct.pack_into("<I", image, entry + 28, 4)
start = (4 + (cluster - 2) * spc) * 512
image[start:start + 512] = b"x" * 512
return image, start, entry
class RawWriteTests(unittest.TestCase):
def setUp(self):
self.image, self.data_offset, self.entry = fat12_image()
self.capacity = len(self.image)
self.info = {"DeviceIdentifier": "disk4", "WholeDisk": True}
self.stack = contextlib.ExitStack()
self.addCleanup(self.stack.close)
self.mock("sys.platform", "darwin")
self.open = self.mock("os.open", return_value=43)
self.close = self.mock("os.close")
self.mock("os.fstat", return_value=SimpleNamespace(st_mode=stat.S_IFCHR))
self.ioctl = self.mock("fcntl.ioctl", side_effect=self.ioctl_result)
self.mock("subprocess.run", side_effect=lambda *a, **k: SimpleNamespace(
stdout=plistlib.dumps(self.info)))
self.mock("os.pread", side_effect=lambda fd, count, offset:
bytes(self.image[offset:offset + count]))
self.pwrite = self.mock("os.pwrite", side_effect=self.write)
self.mock("os.fsync")
def mock(self, name, *args, **kwargs):
return self.stack.enter_context(patch("scripts.write_led_raw." + name,
*args, **kwargs))
def ioctl_result(self, fd, request, buffer):
self.assertEqual(fd, 43)
if request == raw.DKIOCGETBLOCKSIZE:
return struct.pack("=I", 512)
self.assertEqual(request, raw.DKIOCGETBLOCKCOUNT)
return struct.pack("=Q", self.capacity // 512)
def write(self, fd, data, offset):
self.assertEqual(fd, 43)
self.image[offset:offset + len(data)] = data
return len(data)
def refused(self, device="/dev/rdisk4", text="off"):
with self.assertRaises((ValueError, OSError)):
raw.write_led(device, text)
self.pwrite.assert_not_called()
def test_writes_only_data_and_file_size_for_both_paths(self):
for device in ("/dev/disk4", "/dev/rdisk4"):
with self.subTest(device=device):
self.image, start, entry = fat12_image()
expected = bytearray(self.image)
payload = b"#ff00ff\n"
expected[start:start + 512] = payload.ljust(512, b"\0")
struct.pack_into("<I", expected, entry + 28, len(payload))
raw.write_led(device, payload.decode())
self.assertEqual(self.image, expected)
self.close.assert_called_with(43)
def test_nondefault_cluster_and_second_root_sector(self):
self.image, start, entry = fat12_image(cluster=7, entry_index=18, spc=2)
raw.write_led("/dev/rdisk4", "off")
self.assertEqual(self.image[start:start + 512], b"off".ljust(512, b"\0"))
self.assertEqual(struct.unpack_from("<I", self.image, entry + 28)[0], 3)
self.assertEqual([c.args[2] for c in self.pwrite.call_args_list], [start, 1536])
def test_large_device_cannot_hide_behind_small_fat_volume(self):
for size in (300032, 300 * 1024, 1024**4):
with self.subTest(size=size):
self.capacity = size
self.refused()
def test_largest_allowed_512_byte_device(self):
self.capacity = 299520
raw.write_led("/dev/rdisk4", "off")
self.assertEqual(self.pwrite.call_count, 2)
def test_unknown_or_zero_capacity(self):
self.capacity = 0
self.refused()
self.ioctl.side_effect = OSError("capacity unavailable")
self.refused()
def test_capacity_rechecked_before_write(self):
with patch.object(raw, "device_size", side_effect=[174080, 300032]):
self.refused()
def test_partition_and_nondevice_paths_rejected_before_open(self):
for path in ("/dev/disk4s1", "/dev/rdisk4s1", "disk4", "/tmp/disk4", "/dev/disk"):
self.refused(device=path)
self.open.assert_not_called()
def test_mounted_invalid_mount_or_nonwhole_device(self):
for change in ({"MountPoint": "/Volumes/SidePulse"}, {"MountPoint": False},
{"WholeDisk": False},
{"DeviceIdentifier": "disk5"}):
with self.subTest(change=change), patch.dict(self.info, change):
self.refused()
self.open.assert_not_called()
def test_explicit_empty_mountpoint_is_unmounted(self):
self.info["MountPoint"] = ""
raw.write_led("/dev/rdisk4", "off")
self.assertEqual(self.pwrite.call_count, 2)
def test_missing_whole_disk_status_is_rejected(self):
del self.info["WholeDisk"]
self.refused()
self.open.assert_not_called()
def test_regular_file_rejected(self):
self.mock("os.fstat", return_value=SimpleNamespace(st_mode=stat.S_IFREG))
self.refused()
def test_bad_programs_rejected_before_open(self):
for text in ("", "x" * 513, "é" * 257, "off\n" * 21, "off\0"):
self.refused(text=text)
self.open.assert_not_called()
def test_full_sector_program(self):
raw.write_led("/dev/rdisk4", ";" + "x" * 511)
self.assertEqual(self.image[self.data_offset:self.data_offset + 512],
b";" + b"x" * 511)
def test_malformed_fat_and_missing_file_never_write(self):
for offset, data in ((510, b"\0\0"), (16, b"\x02"), (13, b"\0"),
(19, b"\xff\xff"), (22, b"\0\0"), (28, b"\x01"),
(1024, b"\0"), (1050, b"\xff\xff"),
(515, b"\0\0"), (1035, b"\x21")):
with self.subTest(offset=offset):
self.image, _, _ = fat12_image()
self.image[offset:offset + len(data)] = data
self.refused()
def test_short_read_never_writes(self):
self.mock("os.pread", return_value=b"")
self.refused()
def test_short_data_write_stops_before_directory(self):
self.pwrite.side_effect = None
self.pwrite.return_value = 12
with self.assertRaisesRegex(ValueError, "Short disk write"):
raw.write_led("/dev/rdisk4", "off")
self.assertEqual(self.pwrite.call_count, 1)
self.close.assert_called_once_with(43)
def test_symlinks_are_not_followed(self):
self.open.side_effect = OSError("symlink")
self.refused()
self.assertTrue(self.open.call_args.args[1] & raw.os.O_NOFOLLOW)
if __name__ == "__main__":
unittest.main()