diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-10 12:52:12 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-10 13:00:24 -0300 |
| commit | 8b28a0a5101a62fd55c2d55433e0fa899d4623f9 (patch) | |
| tree | de233408fc45f93e19bbcf637ed66242d569fc56 /src | |
| parent | 36d7f642e71207d04f5da80530da552e06447337 (diff) | |
| download | computeranim-8b28a0a5101a62fd55c2d55433e0fa899d4623f9.tar.gz computeranim-8b28a0a5101a62fd55c2d55433e0fa899d4623f9.zip | |
agent: its handlers act with the thread's protection keys and float modes, not a handler's
The kernel starts a signal handler with default PKRU (key 0 only) and
default MXCSR and x87 control word, the thread's own saved in the frame.
The SIGSYS handler makes the thread's syscalls and clones its threads
from there, so under --syscalls:
- a pkey_alloc's new rights were undone when the handler returned;
- a thread was born with no right to keyed memory (V8's compiler
threads fault reading the code space: d8 died of SEGV_PKUERR, and the
35 seconds were its core dump, not a spin);
- a buffer in keyed memory was EFAULT to the kernel, and a fault to the
agent reading it for the event;
- a thread started without its maker's float modes (flush-to-zero).
Both handlers now take the thread's PKRU and control words from the frame
first (signal.adopt), and the SIGSYS one writes PKRU back to the frame
after the syscall. Watched memory is read, and hooked code patched, with
every key open, so a key the thread itself cannot use hides nothing.
test-agent: agent_pkey (a keyed page read, given to syscalls, watched,
read by a later thread; skips itself without keys), and agent_sys's
thread checks its MXCSR. README: --alloc and programs with their own
malloc; the core dump.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Diffstat (limited to 'src')
| -rw-r--r-- | src/agent/agent.zig | 10 | ||||
| -rw-r--r-- | src/agent/check.zig | 35 | ||||
| -rw-r--r-- | src/agent/hook.zig | 15 | ||||
| -rw-r--r-- | src/agent/signal.zig | 97 | ||||
| -rw-r--r-- | src/agent/sud.zig | 12 | ||||
| -rw-r--r-- | src/agent/watch.zig | 4 |
6 files changed, 168 insertions, 5 deletions
diff --git a/src/agent/agent.zig b/src/agent/agent.zig index 2a32a05..0e23de9 100644 --- a/src/agent/agent.zig +++ b/src/agent/agent.zig @@ -45,6 +45,7 @@ pub fn init() void { if (state.load(.acquire) != 0 or state.cmpxchgStrong(0, 1, .acquire, .monotonic) != null) return; defer state.store(2, .release); const r = client.get() orelse return; + signal.keys.detect(); var buf: [1 << 16]u8 = undefined; const env = client.environ(&buf); cut = if (client.getenv(env, "ZTRACE_CUT")) |v| std.fmt.parseInt(u64, v, 0) catch 0 else 0; @@ -161,14 +162,17 @@ pub fn mark(label: []const u8, value: u64) void { /// Names `memory` (a `variable` event), records it, and keeps recording what /// changes in it: only the bytes that changed, before each event that ends a -/// moment. At most `max_region` bytes, which must stay mapped. Watched from -/// inside a hooked call, it is forgotten when that call returns. +/// moment. At most `max_region` bytes, which must stay mapped; a protection +/// key on it does not hide it. Watched from inside a hooked call, it is +/// forgotten when that call returns. pub fn watch(memory: []const u8, name: []const u8) void { init(); if (ring == null or tooLarge(memory, "watch")) return; const was = sud.selector; sud.selector = sud.allow; defer sud.selector = was; + const rights = signal.keys.open(); + defer if (rights) |r| signal.keys.set(r); const id = stringId(name); emit(.string, 0, .{ id, 0, 0, 0, 0, 0 }, text(name, max_payload)); emit(.variable, 0, .{ @intFromPtr(memory.ptr), memory.len, id, 0, 0, 0 }, ""); @@ -180,6 +184,8 @@ pub fn watch(memory: []const u8, name: []const u8) void { pub fn snapshot(memory: []const u8) void { init(); if (ring == null or tooLarge(memory, "snapshot")) return; + const rights = signal.keys.open(); + defer if (rights) |r| signal.keys.set(r); write(@intFromPtr(memory.ptr), memory); } diff --git a/src/agent/check.zig b/src/agent/check.zig index 8657665..348f497 100644 --- a/src/agent/check.zig +++ b/src/agent/check.zig @@ -89,6 +89,8 @@ pub fn main(init: std.process.Init) !void { try annotated(r); } else if (std.mem.eql(u8, scenario, "syscalls")) { try syscalls(r); + } else if (std.mem.eql(u8, scenario, "pkey")) { + try protected(r); } else return error.NoSuchScenario; } @@ -207,6 +209,39 @@ fn annotated(r: Recording) !void { try sorted(r, "numbers"); } +/// agent_pkey: syscalls into memory behind a protection key did what they +/// do natively, from the thread that made the key and from one made after; +/// the page was seen while its thread could not read it. +fn protected(r: Recording) !void { + const SYS = std.os.linux.SYS; + var writers: std.AutoArrayHashMapUnmanaged(u32, void) = .empty; + var reads: std.ArrayList(i64) = .empty; + var key: i64 = -1; + var writing = false; + for (r.items) |item| switch (item.ev.kind) { + .syscall_enter => writing = item.ev.aux == @intFromEnum(SYS.write) and std.mem.eql(u8, item.payload, "protected\n"), + .syscall_exit => if (item.ev.aux == @intFromEnum(SYS.pkey_alloc)) { + key = @bitCast(item.ev.a[0]); + } else if (item.ev.aux == @intFromEnum(SYS.read) and key > 0) { + try reads.append(r.arena, @bitCast(item.ev.a[0])); + } else if (writing) { + try expectEqual(@as(u64, 10), item.ev.a[0]); + try writers.put(r.arena, item.ev.tid, {}); + writing = false; + }, + else => {}, + }; + // No protection keys on this machine: nothing to hold the agent to. + if (key < 0) return; + try expectEqual(@as(usize, 2), writers.count()); + try std.testing.expectEqualSlices(i64, &.{ 16, -@as(i64, @intFromEnum(std.os.linux.E.FAULT)) }, reads.items); + const page = try r.variable("page"); + var text: [10]u8 = undefined; + try (try r.trace.moment(r.trace.len - 1)).read(page.ev.a[0], &text, null); + try expectEqualStrings("protected\n", &text); + try expect(r.count(.mark) == 1 and r.count(.call) == 1); +} + /// agent_sys: what it wrote, from which thread, and every syscall entered /// is left, innermost first. fn syscalls(r: Recording) !void { diff --git a/src/agent/hook.zig b/src/agent/hook.zig index fa44cc4..88e187c 100644 --- a/src/agent/hook.zig +++ b/src/agent/hook.zig @@ -61,15 +61,24 @@ pub fn add(addr: usize) void { const code: *[4]u8 = @ptrFromInt(addr); hooks[count] = .{ .addr = addr, .first = code.* }; count += 1; - code[0] = 0xcc; + poke(addr, 0xcc); +} + +/// One byte of code changed, whatever protection key the code is behind (a JIT's is). +fn poke(addr: usize, byte: u8) void { + const rights = signal.keys.open(); + @as(*u8, @ptrFromInt(addr)).* = byte; + if (rights) |was| signal.keys.set(was); } fn onTrap(_: i32, info: *const linux.siginfo_t, uc: *signal.Ucontext) callconv(.c) void { + // As the thread, not with a handler's defaults: its stack and what is watched are read from here. + signal.adopt(uc); const TRAP_TRACE = 2; if (info.code == TRAP_TRACE) { // The step over a hooked function's first instruction ended. Whose, // nobody wrote down: all the breakpoints go back in. - for (hooks[0..count]) |h| @as(*u8, @ptrFromInt(h.addr)).* = 0xcc; + for (hooks[0..count]) |h| poke(h.addr, 0xcc); uc.eflags &= ~@as(u64, signal.trap_flag); return; } @@ -99,7 +108,7 @@ fn onTrap(_: i32, info: *const linux.siginfo_t, uc: *signal.Ucontext) callconv(. uc.rip += 4; } else { // shortcut: while the byte is back another thread can enter unseen; a relocated copy of the instruction would close that. - @as(*u8, @ptrFromInt(hook.addr)).* = hook.first[0]; + poke(hook.addr, hook.first[0]); uc.eflags |= signal.trap_flag; } } diff --git a/src/agent/signal.zig b/src/agent/signal.zig index 66baf2d..9a14222 100644 --- a/src/agent/signal.zig +++ b/src/agent/signal.zig @@ -51,6 +51,103 @@ pub const Ucontext = extern struct { } }; +/// What a handler has to take back before it acts for the thread it +/// interrupted. The kernel starts every handler with defaults (rights to +/// memory behind protection keys: key 0 only; floating-point modes: the +/// initial ones) and keeps the thread's own in the frame until the handler +/// returns. A syscall made for the thread, a thread started for it, its +/// memory read for it: all would happen as somebody else. +pub fn adopt(uc: *const Ucontext) void { + if (uc.fpstate == 0) return; + const area: [*]const u8 = @ptrFromInt(uc.fpstate); + // FXSAVE: the x87 control word first, MXCSR at 24. + asm volatile ( + \\ fldcw (%[area]) + \\ ldmxcsr 24(%[area]) + : + : [area] "r" (area), + ); + if (keys.inFrame(uc)) |in| keys.set(if (in.present.* & keys.component != 0) in.pkru.* else 0); +} + +/// Memory protection keys: a thread's rights to protected memory are a +/// register, PKRU, two bits a key. +pub const keys = struct { + /// Where XSAVE keeps PKRU; 0 when the CPU or the kernel has no protection keys. + var offset: u32 = 0; + /// PKRU's bit among XSAVE's state components. + const component: u64 = 1 << 9; + + /// Once, before any handler is installed. + pub fn detect() void { + // Leaf 7: the kernel has turned the keys on (OSPKE). Leaf 0xD, component 9: where PKRU is saved. + if (cpuid(7, 0)[2] & (1 << 4) != 0) offset = cpuid(0xd, 9)[1]; + } + + /// eax, ebx, ecx, edx. + fn cpuid(leaf: u32, subleaf: u32) [4]u32 { + var eax: u32 = undefined; + var ebx: u32 = undefined; + var ecx: u32 = undefined; + var edx: u32 = undefined; + asm volatile ("cpuid" + : [a] "={eax}" (eax), + [b] "={ebx}" (ebx), + [c] "={ecx}" (ecx), + [d] "={edx}" (edx), + : [leaf] "{eax}" (leaf), + [subleaf] "{ecx}" (subleaf), + ); + return .{ eax, ebx, ecx, edx }; + } + + pub fn get() u32 { + return asm volatile ("rdpkru" + : [pkru] "={eax}" (-> u32), + : [zero] "{ecx}" (@as(u32, 0)), + : .{ .edx = true }); + } + + pub fn set(pkru: u32) void { + asm volatile ("wrpkru" + : + : [pkru] "{eax}" (pkru), + [c] "{ecx}" (@as(u32, 0)), + [d] "{edx}" (@as(u32, 0)), + ); + } + + /// Every key's memory readable and writable to this thread, for the + /// agent's own look at what is watched or hooked. Returns what to `set` + /// back; null without protection keys. + pub fn open() ?u32 { + if (offset == 0) return null; + const was = get(); + set(0); + return was; + } + + /// The interrupted thread's PKRU in its signal frame, and the header + /// word that says whether it is there at all (absent, it is 0). + fn inFrame(uc: *const Ucontext) ?struct { pkru: *align(1) u32, present: *align(1) u64 } { + if (offset == 0 or uc.fpstate == 0) return null; + const area: [*]u8 = @ptrFromInt(uc.fpstate); + // After FXSAVE's 512 bytes comes XSAVE's header, when the kernel says so at 464. + const extended: *align(1) const extern struct { magic: u32, size: u32, features: u64, state_size: u32 } = @ptrCast(area + 464); + if (extended.magic != 0x46505853 or extended.features & component == 0 or extended.state_size < offset + 4) return null; + return .{ .pkru = @ptrCast(area + offset), .present = @ptrCast(area + 512) }; + } + + /// The rights as they are now are the thread's from the handler's + /// return on: a pkey_alloc made in the handler changed them here, and + /// the frame would put the old ones back. + pub fn keep(uc: *const Ucontext) void { + const in = inFrame(uc) orelse return; + in.pkru.* = get(); + in.present.* |= component; + } +}; + /// The trap flag: one instruction, then SIGTRAP. pub const trap_flag = 0x100; diff --git a/src/agent/sud.zig b/src/agent/sud.zig index 5d2c6ad..41d7cb6 100644 --- a/src/agent/sud.zig +++ b/src/agent/sud.zig @@ -11,6 +11,14 @@ //! always lets through: a signal that interrupts it runs the target's handler //! as the target's code, its syscalls seen like any other. //! +//! The kernel starts a handler with default rights to memory behind +//! protection keys and default floating-point modes, the thread's own put +//! away in the frame. The handler takes the thread's first (`signal.adopt`): +//! otherwise a buffer in protected memory is EFAULT to the syscall, a +//! pkey_alloc's new rights are undone by the handler's return, and a thread +//! cloned here is born without its maker's rights (V8's compiler threads +//! then fault reading the code space). +//! //! The handler runs on an alternate stack of the agent's, one a thread: the //! target's stack may have no room for a signal frame (a thread made with a //! few kilobytes), and a vfork child takes its parent's stack over. @@ -67,6 +75,9 @@ pub fn arm() void { fn onSyscall(_: i32, _: *const linux.siginfo_t, uc: *signal.Ucontext) callconv(.c) void { selector = allow; + // The syscall is the thread's: made with its rights to protected memory, + // and a thread it starts gets its floating-point modes, not a handler's. + signal.adopt(uc); const number = uc.rax; var a = [6]u64{ uc.rdi, uc.rsi, uc.rdx, uc.r10, uc.r8, uc.r9 }; if (number == nr(.rt_sigreturn)) { @@ -113,6 +124,7 @@ fn onSyscall(_: i32, _: *const linux.siginfo_t, uc: *signal.Ucontext) callconv(. if (result == 0 and (number == nr(.fork) or number == nr(.clone) or number == nr(.clone3))) agent.forked(); agent.emit(.syscall_exit, @truncate(number), .{ result, 0, 0, 0, 0, 0 }, ""); uc.rax = result; + signal.keys.keep(uc); selector = block; } diff --git a/src/agent/watch.zig b/src/agent/watch.zig index 356dac8..fb46b09 100644 --- a/src/agent/watch.zig +++ b/src/agent/watch.zig @@ -7,6 +7,7 @@ const std = @import("std"); const linux = std.os.linux; const agent = @import("agent.zig"); +const signal = @import("signal.zig"); const Region = struct { addr: usize, @@ -65,6 +66,9 @@ pub fn diff() void { // Busy: another thread is at it, or this one is, below this frame. if (busy.swap(true, .acquire)) return; defer busy.store(false, .release); + // Whatever key the memory is behind, and whether this thread may read it now. + const rights = signal.keys.open(); + defer if (rights) |was| signal.keys.set(was); for (table[0..count]) |r| { var changes: Changes = .{ .old = r.shadow[0..r.len], .new = @as([*]const u8, @ptrFromInt(r.addr))[0..r.len] }; while (changes.next()) |run| agent.write(r.addr + run.at, run.bytes); |
