diff options
Diffstat (limited to 'anim/scenes/asan.zig')
| -rw-r--r-- | anim/scenes/asan.zig | 563 |
1 files changed, 563 insertions, 0 deletions
diff --git a/anim/scenes/asan.zig b/anim/scenes/asan.zig new file mode 100644 index 0000000..2fe743f --- /dev/null +++ b/anim/scenes/asan.zig @@ -0,0 +1,563 @@ +//! ASan against a plain build (design/motion.md, "A scene: ASan against a +//! plain build"): `overflow.c`'s loop writes 32 bytes into 16, built plain +//! and with AddressSanitizer, the two runs a `pair` (design/README.md): +//! the shared source, each run's disassembly, registers and frame as bytes +//! on its side of the seam, `buf` facing `buf`. They go together to i = 16, +//! where they part: plain stores into its saved rbp, ASan reads `f3` in the +//! shadow and calls its report, which comes in from the run's own `write`s +//! in place of its registers; plain goes on alone, a letter a turn, through +//! the saved rbp and the return address (the held rest at i = 27 is the +//! poster, mock 38), to `ret` and its fault. Beats A1 to A16, the +//! storyboard's texts as written; A10 to A13 in the pair as captions (see +//! the README: the column holds no frame as bytes). +const std = @import("std"); +const anim = @import("anim"); +const canim = @import("canim"); +const recordings = @import("recordings"); +const pair = canim.pair; + +pub const background = canim.background; +pub const scene = anim.Live(frame, struct {}); + +/// The first moment from `from` whose instruction begins with `text`. +fn on(rec: *canim.Recording, from: u64, text: []const u8) u64 { + var buf: [256]u8 = undefined; + var i = from; + while (i < rec.end()) : (i += 1) if (rec.instruction(i, rec.register(i, "rip"), &buf)) |here| if (std.mem.startsWith(u8, here.text, text)) return i; + return rec.end(); +} + +/// The `n`th moment (from 0) from `from` whose pc is `pc`. +fn nth(rec: *canim.Recording, from: u64, pc: u64, n: usize) u64 { + var seen: usize = 0; + var i = from; + while (i < rec.end()) : (i += 1) if (rec.register(i, "rip") == pc) { + if (seen == n) return i; + seen += 1; + }; + return rec.end(); +} + +/// Each moment from here to `until` walked, its whole sentence said in +/// `seconds` (null: as long as it takes). +fn walk(s: *anim.Frame, c: canim.Cursor, until: u64, seconds: ?f32) void { + var here = c.moment(s); + while (here < until) : (here += 1) { + const plan = c.reading(here, here + 1); + c.step(s, here + 1, plan, seconds orelse plan.total); + } +} + +/// Straight to `to` at a run: unmarked, values changing in place under 8 f crossfades. +fn run(s: *anim.Frame, c: canim.Cursor, to: u64, seconds: f32) void { + c.step(s, to, canim.Plan.running(seconds), seconds); +} + +/// To `until` at a run, `per` moments a step (each step at least 18 f: the +/// mark's 8 f ease and its 8 f advance), the first steps as long as `ramp` +/// says and the rest as long as its last. +fn runTo(s: *anim.Frame, c: canim.Cursor, until: u64, per: u64, ramp: []const f32) void { + var here = c.moment(s); + var k: usize = 0; + while (here < until) : (k += 1) { + const next = @min(here + per, until); + const sec = ramp[@min(k, ramp.len - 1)]; + run(s, c, next, sec); + here = next; + } +} + +/// The two runs from one instant: the scene goes on when the later is done. +const Together = struct { + start: f32, + end: f32, + fn begin(s: *anim.Frame) Together { + return .{ .start = s.cursor, .end = s.cursor }; + } + /// The next run's part, from the same start. + fn next(tg: *Together, s: *anim.Frame) void { + tg.end = @max(tg.end, s.cursor); + s.cursor = tg.start; + } + fn done(tg: *Together, s: *anim.Frame) void { + s.cursor = @max(tg.end, s.cursor); + } +}; + +/// Of the right run's function, the rows no row of the left faces (`only +/// here`): all but the frame's own instructions, the loop counter's (the +/// memory the loop's `cmp …, 0x20` reads), the branch after that compare, +/// `add eax, 1`, the store of 'A', and the jump back to the compare. +fn onlyHere(a: std.mem.Allocator, rec: *canim.Recording, at: u64, start: u64) []const u64 { + var out: std.ArrayList(u64) = .empty; + var buf: [256]u8 = undefined; + var counter: []const u8 = ""; + var head: u64 = 0; + var addr = start; + var after_head = false; + while (rec.instruction(at, addr, &buf)) |one| : (addr += one.len) { + const text = a.dupe(u8, one.text) catch break; + if (std.mem.startsWith(u8, text, "cmp dword ptr [") and std.mem.endsWith(u8, text, ", 0x20")) { + counter = text[std.mem.indexOfScalar(u8, text, '[').? .. std.mem.indexOfScalar(u8, text, ']').? + 1]; + head = addr; + } + } + addr = start; + while (rec.instruction(at, addr, &buf)) |one| : (addr += one.len) { + const text = one.text; + const jump_back = std.mem.startsWith(u8, text, "jmp") and std.mem.endsWith(u8, text, a.dupe(u8, std.fmt.bufPrint(buf[200..], "0x{x}", .{head}) catch "") catch ""); + const faces = std.mem.eql(u8, text, "push rbp") or std.mem.eql(u8, text, "mov rbp, rsp") or std.mem.eql(u8, text, "pop rbp") or + (counter.len > 0 and std.mem.indexOf(u8, text, counter) != null) or after_head or std.mem.eql(u8, text, "add eax, 1") or + (std.mem.startsWith(u8, text, "mov byte ptr") and std.mem.endsWith(u8, text, ", 0x41")) or jump_back; + after_head = addr == head; + if (!faces) out.append(a, addr) catch break; + if (std.mem.eql(u8, text, "ret")) break; + } + return out.items; +} + +/// The signal that stopped the run, if one did: its moment and its name. +fn signal(rec: *canim.Recording) ?struct { at: u64, name: []const u8 } { + var i = rec.end(); + while (i > 0) { + i -= 1; + var events = rec.moment(i).events(std.heap.page_allocator) catch continue; + defer events.deinit(std.heap.page_allocator); + while (events.next()) |item| if (item.ev.kind == .signal) { + return .{ .at = i, .name = switch (item.ev.aux) { + 4 => "SIGILL", + 5 => "SIGTRAP", + 6 => "SIGABRT", + 7 => "SIGBUS", + 8 => "SIGFPE", + 11 => "SIGSEGV", + else => "a signal", + } }; + }; + } + return null; +} + +/// A stopped run's tag on the shelf: `stopped:` and its report's first words +/// (the error's kind, and the access: `stack-buffer-overflow, WRITE of size 1`). +fn stopped(a: std.mem.Allocator, said: []const u8) []const u8 { + const kind = blk: { + const at = std.mem.indexOf(u8, said, "AddressSanitizer: ") orelse break :blk ""; + const rest = said[at + "AddressSanitizer: ".len ..]; + break :blk rest[0 .. std.mem.indexOfAny(u8, rest, " \n") orelse rest.len]; + }; + const access = blk: { + const at = std.mem.indexOf(u8, said, "WRITE of size") orelse std.mem.indexOf(u8, said, "READ of size") orelse break :blk ""; + const rest = said[at..]; + break :blk rest[0 .. std.mem.indexOf(u8, rest, " at ") orelse rest.len]; + }; + return std.fmt.allocPrint(a, "stopped: {s}, {s}", .{ kind, access }) catch "stopped"; +} + +fn frame(s: *anim.Frame) void { + const plain = canim.open(recordings.overflow); + const asan = canim.open(recordings.overflow_asan); + const report = canim.open(recordings.overflow_report); + const t = canim.theme.time; + + // Plain: main's call; fill's line 4; the turns, each from its compare; the store of each; the way out. + const p_call = on(plain, plain.call("main", 0).enter, "call"); + const p_line4 = plain.lineMoment(4, p_call + 1); + const p_head = plain.register(on(plain, p_line4, "cmp"), "rip"); + var p_turn: [33]u64 = undefined; + var p_store: [32]u64 = undefined; + for (&p_turn, 0..) |*m, i| m.* = nth(plain, p_line4, p_head, i); + for (&p_store, 0..) |*m, i| m.* = on(plain, p_turn[i], "mov byte ptr"); + const p_pop = on(plain, p_turn[32], "pop rbp"); + const fault = signal(plain); + const p_end = if (fault) |f| f.at else p_pop + 2; + + // ASan: the same call; its prologue and `__asan_stack_malloc_0`, stepped over; line 3; the turns. + const q_call = on(asan, asan.call("main", 0).enter, "call"); + const q_fill = q_call + 1; + const q_malloc = on(asan, q_fill, "call"); + var ibuf: [256]u8 = undefined; + const malloc_pc = asan.register(q_malloc, "rip"); + const q_back = nth(asan, q_malloc + 1, malloc_pc + asan.instruction(q_malloc, malloc_pc, &ibuf).?.len, 0); + const q_line3 = asan.lineMoment(3, q_back); + const q_line4 = asan.lineMoment(4, q_line3); + const q_head = asan.register(on(asan, q_line4, "cmp dword ptr"), "rip"); + var q_turn: [17]u64 = undefined; + for (&q_turn, 0..) |*m, i| m.* = nth(asan, q_line4, q_head, i); + const q_load = struct { + fn of(rec: *canim.Recording, from: u64) u64 { + var buf: [256]u8 = undefined; + var i = from; + while (i < rec.end()) : (i += 1) if (rec.instruction(i, rec.register(i, "rip"), &buf)) |here| if (std.mem.indexOf(u8, here.text, "0x7fff8000]") != null) return i; + return rec.end(); + } + }.of; + const report_call = on(asan, q_load(asan, q_turn[16]), "call"); + + // The frames: plain's from rbp at line 4 (`i` at rbp-0x14, `buf` at rbp-0x10, then the saved rbp and the + // return address); ASan's fake frame, where `__asan_stack_malloc_0` put it, by its descriptor. + const rbp = plain.register(p_line4, "rbp"); + const buf = rbp - 0x10; + const fake = asan.register(q_back, "rax"); + const real = asan.register(q_line4, "rbp"); + // The descriptor ("1 32 16 5 buf:3"): one variable, at 32, 16 long. + var var_at: u64 = 32; + var var_len: u64 = 16; + if (canim.Recording.word(asan.moment(q_line3), fake + 8, 8) catch null) |descr| { + var text: [32]u8 = undefined; + var known: [32]bool = undefined; + if (asan.moment(q_line3).read(descr, &text, &known)) |_| { + var it = std.mem.tokenizeScalar(u8, text[0 .. std.mem.indexOfScalar(u8, &text, 0) orelse text.len], ' '); + _ = it.next(); + if (it.next()) |a| var_at = std.fmt.parseInt(u64, a, 10) catch var_at; + if (it.next()) |a| var_len = std.fmt.parseInt(u64, a, 10) catch var_len; + } else |_| {} + } + const fake_buf = fake + var_at; + + var at = canim.cursor(s, plain, p_call); + var as = canim.cursor(s, asan, q_call); + for ([_]*canim.Cursor{ &at, &as }) |c| c.levels = .{ .source_rows = 5, .fire = .disasm }; + at.journey(.moment, p_end); + as.journey(.moment, report_call); + + const left = canim.Stage.init(s, pair.split(.left, false)); + const right = canim.Stage.init(s, pair.split(.right, false)); + const fake_in = s.value(0); + const differs = s.value(0); + const attention = s.value(0); + const framed = s.value(0); + + const source = canim.add(s, canim.Source{ .cursor = at, .stage = left, .tag = "both builds" }); + const dis_l = canim.add(s, canim.Disasm{ .cursor = at, .stage = left }); + // In the column (A10 to A13) plain's disassembly is a descent: main's window, the row + // its return address names among them, over fill's whole (motion.md, the column's panes). + const desc_l = canim.add(s, canim.Descent{ .cursor = at, .stage = left }); + const dis_r = canim.add(s, canim.Disasm{ .cursor = as, .stage = right, .rows = 9 }); + const reg_moves = struct { + fn of(names: []const []const u8) u32 { + var mask: u32 = 0; + for (names) |n| for (canim.ztrace.Regs.names, 0..) |known, i| { + if (std.mem.eql(u8, known, n)) mask |= @as(u32, 1) << @intCast(i); + }; + return mask; + } + }.of; + const regs_l = canim.add(s, canim.Registers{ .cursor = at, .stage = left, .moves = reg_moves(&.{ "rax", "rbp", "rsp", "rip" }), .folds = false, .title = "plain \u{00b7} registers" }); + const regs_r = canim.add(s, canim.Registers{ .cursor = as, .stage = right, .moves = reg_moves(&.{ "rax", "rbx", "rcx", "rip" }), .folds = false, .title = "asan \u{00b7} registers" }); + const offset = pair.shadowOffset(asan) orelse 0x7fff8000; + const frame_l = canim.add(s, pair.Frame{ + .cursor = at, + .stage = left, + .title = "plain \u{00b7} stack", + .note = "fill's frame as bytes, eight a row", + .first = buf - 32, + .rows = 10, + .fields = s.arena.dupe(pair.Field, &.{ + .{ .at = rbp - 0x14, .len = 4, .name = "i", .from = p_line4 }, + .{ .at = buf, .len = 16, .name = "buf", .reads = .text, .from = p_line4 }, + .{ .at = rbp, .len = 8, .name = "saved rbp", .reads = .pointer, .from = p_call + 2 }, + .{ .at = rbp + 8, .len = 8, .name = "return", .reads = .pointer, .from = p_call + 1 }, + }) catch unreachable, + .letters = buf, + .span = .{ rbp - 0x18, rbp + 16 }, + .span_from = p_call + 1, + .tall = rbp - 0x18, + .name = "fill", + .side = .left, + .shows = s.value(1), + .differs = differs, + .differ = s.arena.dupe(u64, &.{ rbp, rbp + 8 }) catch unreachable, + }); + const frame_r = canim.add(s, pair.Frame{ + .cursor = as, + .stage = right, + .title = "asan \u{00b7} fake frame", + .note = std.fmt.allocPrint(s.arena, "its shadow at addr >> 3 + {x} \u{00b7} then the real stack's way back", .{offset}) catch "", + .first = fake, + .rows = 8, + .then = real, + .more = 2, + .fields = s.arena.dupe(pair.Field, &.{ + .{ .at = fake, .len = 8, .name = "magic", .reads = .bytes }, + .{ .at = fake + 8, .len = 8, .name = "descr", .reads = .pointer }, + .{ .at = fake + 16, .len = 8, .name = "pc", .reads = .pointer }, + .{ .at = fake + 24, .len = 8, .name = "real stack", .reads = .pointer }, + .{ .at = fake_buf, .len = var_len, .name = "buf", .reads = .text }, + .{ .at = fake_buf + var_len, .len = 8, .name = "redzone", .reads = .bytes }, + .{ .at = fake_buf + var_len + 8, .len = 8, .name = "redzone", .reads = .bytes }, + .{ .at = real, .len = 8, .name = "saved rbp", .reads = .pointer, .from = q_fill + 1 }, + .{ .at = real + 8, .len = 8, .name = "return", .reads = .pointer, .from = q_fill }, + }) catch unreachable, + .letters = fake_buf, + .shadow = true, + .span = .{ fake, real + 16 }, + .span_from = q_fill, + .name = "fill", + .side = .right, + .shows = fake_in, + .differs = differs, + .differ = s.arena.dupe(u64, &.{ fake_buf + var_len, fake_buf + var_len + 8 }) catch unreachable, + }); + const stderr = canim.add(s, pair.Report{ + .rec = report, + .stage = right, + .title = "asan \u{00b7} stderr", + .lines = &.{ "ERROR: AddressSanitizer", "WRITE of size", "is located in stack", "This frame has", "<== Memory access", "=>0x" }, + .words = &.{ "stack-buffer-overflow", "WRITE of size 1", "[32, 48) 'buf'", "[f3]" }, + .framed = framed, + }); + const store_pc = plain.register(p_store[0], "rip"); + const load_pc = asan.register(q_load(asan, q_turn[0]), "rip"); + const right_shows = s.value(1); + const marks = canim.add(s, pair.Marks{ + .left = at, + .right = as, + .stages = .{ left, right }, + .name = "asan", + .only = onlyHere(s.arena, asan, q_fill, asan.register(q_fill, "rip")), + .attend = .{ store_pc, load_pc }, + .attention = attention, + .right_shows = right_shows, + .fault = if (fault) |f| .{ .at = f.at, .pc = plain.register(f.at, "rip"), .name = f.name } else null, + }); + const clock = canim.add(s, pair.Clock{ .left = at, .right = as, .names = .{ "plain", "asan" }, .counter = rbp - 0x14, .counting = p_line4 + 1, .stage = left }); + // A10 to A13 in the column (`canim.column`): plain's panes, its frame as bytes the column's height; ASan's + // side folded to one tag on the shelf, its report's first line its note. + const col = canim.column(s, .{ .stage = left, .source = source, .disasm = dis_l, .registers = regs_l, .stack = frame_l, .backtrace = frame_l, .cursor = at }, .{}); + const shelf_fold = s.value(0); + const said = pair.Report.stderr(report, s.arena); + const shelf = canim.add(s, pair.Shelf{ .stage = right, .title = "asan", .note = stopped(s.arena, said), .fold = shelf_fold }); + // No ties across the seam: this one draws nothing (no thread, no stack words) and clears the frame's places. + const joins = canim.add(s, canim.Ties{ .cursor = at, .stage = left, .threaded = false, .quiet = true }); + s.play(.{ marks.fadeIn(), joins.fadeIn(), shelf.fadeIn() }, .{ .seconds = 0 }); + var says: canim.Narrator = .{}; + + canim.establish(s, .{ clock, source, dis_l, dis_r, regs_l, regs_r, frame_l, frame_r }); + + // A1: fill() called in both, as any call. + says.line(s, "Plain against AddressSanitizer: a loop writes 32 bytes into 16."); + var tg = Together.begin(s); + walk(s, at, p_call + 1, null); + tg.next(s); + walk(s, as, q_fill, null); + tg.done(s); + + // A2: line 2, the prologues: plain's two rows walked; ASan's at a run (four rows a step), its + // stack_malloc stepped over, the fake frame's rows coming in as it is made; then the store that + // poisons the shadow walked, its cells struck 2 f apart. + says.line(s, "ASan's prologue moves `buf` to a fake frame\nand poisons its shadow: `f1` before `buf`, `f3` after."); + tg = Together.begin(s); + walk(s, at, p_line4, null); + tg.next(s); + { + const start = s.cursor; + s.play(.{ as.veil.to(1), as.hurried.to(1) }, .{ .seconds = t.veil }); + s.cursor = start; + // Ramping in: each step 0.6 of the one before, to a run's 18 f. + runTo(s, as, q_malloc, 4, &.{ 0.5, 0.36, 0.3 }); + run(s, as, q_back, 0.4); + // The fake frame is made: its rows come in (12 f). + const made = s.cursor; + s.play(.{fake_in.to(1)}, .{ .seconds = t.quick }); + s.cursor = made; + runTo(s, as, q_line3 - 1, 5, &.{ 0.3, 0.36, 0.5 }); + s.play(.{ as.veil.to(0), as.hurried.to(0) }, .{ .seconds = t.veil }); + s.wait(t.beat); + walk(s, as, q_line3, null); + } + tg.done(s); + + // A3: line 3, ASan's alone: buf's shadow f8 f8 turns 00 00. + says.line(s, "Line 3 is ASan's alone: `buf`'s shadow `f8 f8` turns `00 00`."); + // One step under a text read for 4.8 s: said slower, so that it covers the reading. + walk(s, as, q_line4, 2.2); + + // A4: i = 0, the check: plain at a run to its store, where it waits facing ASan's check; ASan's + // counter and compare at a run, then its address and check rows walked, 30 f a row, the load longer. + says.line(s, "Before each store ASan reads `buf[i]`'s shadow byte,\nat `(addr >> 3) + 7fff8000`."); + const q_check0 = q_load(asan, q_turn[0]); + tg = Together.begin(s); + runTo(s, at, p_store[0], 1, &.{ 0.4, 0.3, 0.3 }); + tg.next(s); + runTo(s, as, q_turn[0] + 2, 1, &.{ 0.4, 0.3, 0.3 }); + walk(s, as, q_check0, 0.5); + walk(s, as, q_check0 + 1, 0.9); + walk(s, as, q_check0 + 3, 0.5); + tg.done(s); + + // A5: i = 0, the stores: ASan's rows after the check, then both stores, plain first, and each side's i++. + says.line(s, "It is `00`: the store may go. Both write `'A'`;\nplain in one instruction, ASan in seventeen."); + const q_store0 = on(asan, q_check0, "mov byte ptr"); + walk(s, as, q_store0, 0.5); + tg = Together.begin(s); + walk(s, at, p_store[0] + 1, null); + tg.next(s); + s.wait(6.0 / 60.0); + walk(s, as, q_store0 + 1, null); + tg.done(s); + tg = Together.begin(s); + runTo(s, at, p_turn[1], 1, &.{ 0.3, 0.3, 0.36 }); + tg.next(s); + runTo(s, as, q_turn[1], 1, &.{ 0.3, 0.3, 0.36 }); + tg.done(s); + + // A6: i = 1 to 14 at a run, a turn a step on each side, ramping in and out. + says.line(s, "Fourteen more turns, at a run: `buf` fills on both sides."); + { + const start = s.cursor; + s.play(.{ at.veil.to(1), at.hurried.to(1), as.veil.to(1), as.hurried.to(1) }, .{ .seconds = t.veil }); + s.cursor = start; + const paces = [_]f32{ 0.6, 0.36, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.36, 0.6 }; + for (paces, 1..) |sec, i| { + tg = Together.begin(s); + run(s, at, p_turn[i + 1], sec); + tg.next(s); + run(s, as, q_turn[i + 1], sec); + tg.done(s); + } + s.play(.{ at.veil.to(0), at.hurried.to(0), as.veil.to(0), as.hurried.to(0) }, .{ .seconds = t.veil }); + s.wait(t.beat); + } + + // A7: i = 15: the rows to each side's store at a run, ASan's load walked (the last 00 read), both stores + // walked, plain first; then each side's i++ at a run, to the turn's first row. + says.line(s, "i = 15, `buf`'s last byte:\nstill `00` on ASan's side, still `buf` on plain's."); + const q_check15 = q_load(asan, q_turn[15]); + const q_store15 = on(asan, q_check15, "mov byte ptr"); + tg = Together.begin(s); + runTo(s, at, p_store[15], 2, &.{ 0.4, 0.4 }); + tg.next(s); + runTo(s, as, q_check15, 2, &.{ 0.4, 0.3, 0.3 }); + walk(s, as, q_check15 + 1, 1.0); + runTo(s, as, q_store15, 3, &.{0.3}); + tg.done(s); + tg = Together.begin(s); + walk(s, at, p_store[15] + 1, 1.4); + run(s, at, p_turn[16], 0.4); + tg.next(s); + s.wait(6.0 / 60.0); + walk(s, as, q_store15 + 1, 1.4); + run(s, as, q_turn[16], 0.4); + tg.done(s); + + // A8: i = 16, they part (the storyboard's chart): plain to its store at a run over the time ASan takes + // to reach its check; the two first different rows framed `attention`; plain's store into the saved + // rbp, its `differs` bar 12 f after; ASan's load reads f3, its compare, its `je` not taken. + says.line(s, "i = 16, one past `buf`: plain writes an A into the saved rbp;\nASan reads `f3`, a redzone."); + const q_check16 = q_load(asan, q_turn[16]); + tg = Together.begin(s); + runTo(s, at, p_store[16], 1, &.{ 0.4, 0.4, 0.4 }); + tg.next(s); + runTo(s, as, q_check16, 4, &.{ 0.6, 0.6 }); + tg.done(s); + s.play(.{attention.to(1)}, .{ .seconds = 6.0 / 60.0 }); + s.wait(6.0 / 60.0); + tg = Together.begin(s); + { + const plan = at.reading(p_store[16], p_store[16] + 1); + at.step(s, p_store[16] + 1, plan, plan.total); + const after = s.cursor; + s.cursor = tg.start + plan.at[1] + 12.0 / 60.0; + s.play(.{differs.to(1)}, .{ .seconds = t.quick }); + s.cursor = after; + } + tg.next(s); + s.wait(30.0 / 60.0); + for (q_check16..q_check16 + 3) |m| { + const plan = as.reading(m, m + 1); + as.step(s, m + 1, plan, plan.total * 0.75); + } + tg.done(s); + s.play(.{attention.to(0)}, .{ .seconds = t.quick }); + + // A9: ASan's partial check and its call walked; its run stops: its registers give way to its stderr. + says.line(s, "ASan does not store: it calls its report,\nwhich names `buf` and the write."); + // The partial check's compare and branch walked; the loads round them at a run. + runTo(s, as, q_check16 + 7, 1, &.{0.3}); + walk(s, as, q_check16 + 9, 0.9); + runTo(s, as, report_call, 1, &.{0.3}); + s.wait(t.beat); + s.play(.{regs_r.fadeOut()}, .{ .seconds = t.quick, .ease = anim.ease.linear }); + right.glide(s, pair.split(.right, true), 0.4); + s.play(.{stderr.fadeIn()}, .{ .seconds = t.quick, .ease = anim.ease.linear }); + s.play(.{framed.to(3)}, .{ .seconds = 18.0 / 60.0, .ease = anim.ease.linear }); + + // A10 to A13: plain goes on alone, a store a turn, into the saved rbp and then the return address, + // in the column: the caption leaves; ASan's side folds to one tag on the shelf; plain's panes glide left + // and its frame's bytes open to the column's height; each text level with the field the turn's letter lands in. + const Store = struct { + /// Turn `i`: its rows up to the store at a run, then the store walked. + fn turn(sf: *anim.Frame, c: canim.Cursor, store: u64) void { + turnIn(sf, c, store, 78.0 / 60.0); + } + /// The same, the store's step `seconds` long (the aim's glide or fray in it, its text read within the beat). + fn turnIn(sf: *anim.Frame, c: canim.Cursor, store: u64, seconds: f32) void { + run(sf, c, store, 18.0 / 60.0); + walk(sf, c, store + 1, seconds); + } + }; + s.wait(@max(says.read_by - s.cursor, 0)); + if (says.current) |caption| { + const out = s.cursor; + s.play(.{caption.fadeOut()}, .{ .seconds = t.caption_out, .ease = canim.ease.exit }); + s.cursor = out; + } + s.play(.{ dis_r.fadeOut(), stderr.fadeOut(), frame_r.fadeOut(), right_shows.to(0), differs.to(0), shelf_fold.to(1), dis_l.fadeOut(), desc_l.fadeIn() }, .{ .seconds = t.quick, .ease = anim.ease.linear }); + s.play(.{shelf_fold.to(2)}, .{ .seconds = 18.0 / 60.0, .ease = anim.ease.linear }); + col.beat(s, .{ .panes = &.{ .{ .source, 3 }, .{ .disasm, 18 }, .{ .stack, canim.column_rest } }, .say = "Plain goes on alone, an A a turn, into the saved rbp.", .level = .{ .row = rbp } }); + { + // `aim = .standing` for these four beats: once the bubble has arrived, the return + // address's field aims at the row it names (18 f), in the lead before the first store. + const fires = s.cursor; + s.cursor = fires - 0.7; + at.aim(s, .standing); + s.cursor = fires; + } + for (17..21) |i| Store.turn(s, at, p_store[i]); + col.beat(s, .{ .panes = &.{ .{ .source, 3 }, .{ .disasm, 18 }, .{ .stack, canim.column_rest } }, .say = "The saved rbp fills: `4141414141414141`, no longer an address.", .level = .{ .row = rbp } }); + for (21..24) |i| Store.turn(s, at, p_store[i]); + col.beat(s, .{ .panes = &.{ .{ .source, 3 }, .{ .disasm, 18 }, .{ .stack, canim.column_rest } }, .say = "i = 24, the return address: it reads `fill+1`, still code.", .level = .{ .row = rbp + 8 } }); + Store.turnIn(s, at, p_store[24], 132.0 / 60.0); + col.beat(s, .{ .panes = &.{ .{ .source, 3 }, .{ .disasm, 18 }, .{ .stack, canim.column_rest } }, .say = "Each turn makes it stranger: `404141` is data, `414141` is nowhere.", .level = .{ .row = rbp + 8 } }); + for (25..27) |i| Store.turnIn(s, at, p_store[i], 128.0 / 60.0); + // Back to the pair: the aim goes with the column; the texts leave together, plain's panes glide back to their side, ASan's unfolds from the shelf. + at.aim(s, .off); + col.beat(s, .{ .at = .below, .say = "" }); + s.play(.{ desc_l.fadeOut(), dis_l.fadeIn() }, .{ .seconds = t.quick, .ease = anim.ease.linear }); + s.play(.{shelf_fold.to(1)}, .{ .seconds = 18.0 / 60.0, .ease = anim.ease.linear }); + s.play(.{ dis_r.fadeIn(), stderr.fadeIn(), frame_r.fadeIn(), right_shows.to(1), differs.to(1), shelf_fold.to(0) }, .{ .seconds = t.quick, .ease = anim.ease.linear }); + says.read_by = 0; + + // A14: i = 27 walked, then the held rest (the poster: mock 38), ASan standing on its report. + says.line(s, "Half written: `41414141`, no longer an address.\nOn the right, ASan stopped at the first byte past `buf`."); + run(s, at, p_store[27], 18.0 / 60.0); + { + // Its hold runs on under its own text (4.9 s): the struck byte solid, the plaque on the store. + var plan = at.reading(p_store[27], p_store[27] + 1); + const held = 4.9; + plan.advance += held; + plan.total += held; + const start = s.cursor; + at.step(s, p_store[27] + 1, plan, plan.total); + const after = s.cursor; + // ASan's side, read meanwhile: the shadow byte its check stopped on, framed in its report. + s.cursor = start + plan.at[1] + 1.0; + s.play(.{framed.to(4)}, .{ .seconds = t.quick, .ease = anim.ease.linear }); + s.cursor = after; + } + + // A15: i = 28 to 31. + says.line(s, "Four more turns: the last A lands,\nand it reads `4141414141414141`."); + for (28..32) |i| Store.turn(s, at, p_store[i]); + + // A16: the loop's exit, pop rbp, ret, and the fault. + says.line(s, "The loop ends: `pop rbp`, then `ret` to `4141414141414141`:\nthe CPU faults. SIGSEGV."); + run(s, at, p_turn[32], 18.0 / 60.0); + runTo(s, at, p_pop, 1, &.{ 0.4, 0.4 }); + for (p_pop..p_end) |m| { + const plan = at.reading(m, m + 1); + at.step(s, m + 1, plan, if (m + 1 == p_end) plan.total else plan.total * 0.8); + } + says.close(s); +} |
