diff options
Diffstat (limited to 'design/mock/touch.py')
| -rw-r--r-- | design/mock/touch.py | 883 |
1 files changed, 883 insertions, 0 deletions
diff --git a/design/mock/touch.py b/design/mock/touch.py new file mode 100644 index 0000000..0ec34a0 --- /dev/null +++ b/design/mock/touch.py @@ -0,0 +1,883 @@ +#!/usr/bin/env python3 +"""The disassembly and the stack tied: `insn`'s annotation `tied` against `whole`, and the `touch` between them. + + python3 -B touch.py # 44-tied-store, 45-tied-load, 46-tied-call, 47-tied-prologue, 48-tied-ways (.png) + +The data is a recording of anim/tools/list.c built as the scene builds it (clang -O0 -g -no-pie +-fno-stack-protector -Wl,-z,now) with -mno-red-zone in place of the instrumentation's call, which is what gave the +scene's `reverse` its `sub rsp`: `env -i setarch -R ztrace record --by insn --from '*0x40126d' --steps 70 +--stack 1024 --around 256 --disasm 69`, moments 32 (main at `call reverse`) to 37 (`prev = NULL` done) and 56 to +58 (the loop's second turn: `next = cur->next` stored, then `prev` loaded for `cur->next = prev`); the words of +the stack past the eight `ztrace show` prints, and the heap, from `ztrace dbg` at the same call (`x`). The roles +are what the recording's `telescope.slots` gives at these pcs: the locals by the debug info (`next` only inside +the loop's block), the saved rbp by the call frame information, the return address. +Each frame is drawn twice: `whole` (the annotation as the catalogue had it: the address, the chain, the value) +and `tied` (the place's name and the value; the stack counting from the frame's base; the `touch`). +""" +import subprocess + +from PIL import Image, ImageDraw, ImageFont + +import gen +import context as C +import map as M +import frame as F +from context import (PAGE, RAISED, RULE, VELLUM, BRIGHT, DIM, FAINT, GOLD, HEAP, STACK, CODE, DATA, A, S, ROW, TAG, + MONO, BOLD, b, ph, mix, Svg) + +HERE = gen.HERE +READ, VERM = gen.READ, gen.VERM +TOP, FOOT = 48, 888 +SRC = open(HERE + "/../../anim/tools/list.c").read().split("\n") + +# ---- the program ------------------------------------------------------------------------------------------ +SYMS = {0x401050: "_start", 0x401110: "__do_global_dtors_aux", 0x401150: "push", 0x4011a0: "reverse", + 0x401200: "clear", 0x401240: "main"} +DIS = [ # objdump -dl of main and of reverse: address, line, mnemonic, operands as the recording writes them + (0x401240, 37, "push", "rbp"), (0x401241, 37, "mov", "rbp, rsp"), (0x401244, 37, "sub", "rsp, 0x10"), + (0x401248, 37, "mov", "dword ptr [rbp - 4], 0"), (0x40124f, 38, "mov", "edi, 7"), (0x401254, 38, "call", 0x401150), + (0x401259, 39, "mov", "edi, 0xc"), (0x40125e, 39, "call", 0x401150), (0x401263, 40, "mov", "edi, 9"), + (0x401268, 40, "call", 0x401150), (0x40126d, 41, "call", 0x4011a0), (0x401272, 42, "call", 0x401200), + (0x401277, 43, "xor", "eax, eax"), (0x401279, 43, "add", "rsp, 0x10"), (0x40127d, 43, "pop", "rbp"), + (0x40127e, 43, "ret", ""), +] +REV = [ + (0x4011a0, 17, "push", "rbp"), (0x4011a1, 17, "mov", "rbp, rsp"), (0x4011a4, 17, "sub", "rsp, 0x18"), + (0x4011a8, 18, "mov", "qword ptr [rbp - 8], 0"), (0x4011b0, 19, "mov", "rax, qword ptr [rip + 0x2e61]"), + (0x4011b7, 19, "mov", "qword ptr [rbp - 0x10], rax"), (0x4011bb, 20, "cmp", "qword ptr [rbp - 0x10], 0"), + (0x4011c0, 20, "je", 0x4011ec), (0x4011c2, 21, "mov", "rax, qword ptr [rbp - 0x10]"), + (0x4011c6, 21, "mov", "rax, qword ptr [rax + 8]"), (0x4011ca, 21, "mov", "qword ptr [rbp - 0x18], rax"), + (0x4011ce, 22, "mov", "rcx, qword ptr [rbp - 8]"), (0x4011d2, 22, "mov", "rax, qword ptr [rbp - 0x10]"), + (0x4011d6, 22, "mov", "qword ptr [rax + 8], rcx"), (0x4011da, 23, "mov", "rax, qword ptr [rbp - 0x10]"), + (0x4011de, 23, "mov", "qword ptr [rbp - 8], rax"), (0x4011e2, 24, "mov", "rax, qword ptr [rbp - 0x18]"), + (0x4011e6, 24, "mov", "qword ptr [rbp - 0x10], rax"), (0x4011ea, 20, "jmp", 0x4011bb), + (0x4011ec, 26, "mov", "rax, qword ptr [rbp - 8]"), (0x4011f0, 26, "mov", "qword ptr [rip + 0x2e21], rax"), + (0x4011f7, 27, "add", "rsp, 0x18"), (0x4011fb, 27, "pop", "rbp"), (0x4011fc, 27, "ret", ""), +] + + +def region(v): + for lo, hi, ink in [(0x7ffffffde000, 0x7ffffffff000, STACK), (0x405000, 0x426000, HEAP), (0x401000, 0x402000, CODE), + (0x404000, 0x405000, DATA), (0x403000, 0x404000, VELLUM), (0x7ffff7c24000, 0x7ffff7d9f000, CODE), + (0x7ffff7e15000, 0x7ffff7e23000, DATA), (0x7ffff7fbf000, 0x7ffff7fec000, CODE), + (0x7ffff7ffb000, 0x7ffff7fff000, DATA)]: + if lo <= v < hi: + return ink + return None + + +def name(v): + if 0x7ffff7c00000 <= v < 0x7ffff7e23000: + return "libc+%x" % (v - 0x7ffff7c00000) + if 0x7ffff7fbe000 <= v < 0x7ffff7fff000: + return "ld.so+%x" % (v - 0x7ffff7fbe000) + f = max(a for a in SYMS if a <= v) + return "%s+%d" % (SYMS[f], v - f) + + +# ---- memory: the stack and the heap at the call (ztrace dbg's `x`), and what each moment after it wrote ------ +BASE = {0x7fffffffecb0: 0, 0x7fffffffecb8: 0, 0x7fffffffecc0: 0x7fffffffece0, 0x7fffffffecc8: 0x401166, 0x7fffffffecd0: 0x405050, 0x7fffffffecd8: 9, + 0x7fffffffece0: 0x7fffffffed00, 0x7fffffffece8: 0x40126d, 0x7fffffffecf0: 0, 0x7fffffffecf8: 0, + 0x7fffffffed00: 0x7fffffffedb0, 0x7fffffffed08: 0x7ffff7c27781, 0x7fffffffed10: 0x7ffff7fe0c60, + 0x7fffffffed18: 0x7fffffffee38, 0x7fffffffed20: 0x1f7fbe000, 0x7fffffffed28: 0x401240, + 0x7fffffffed30: 0x7fffffffed70, 0x7fffffffed38: 0x7ffff7fdf260, 0x7fffffffed40: 0, + 0x7fffffffed48: 0x3047b20d27c51ddb, 0x7fffffffed50: 0x7fffffffee38, 0x7fffffffed58: 1, + # what the chains lead to (the recording's telescope) + 0x7fffffffedb0: 0x7fffffffee10, 0x7fffffffee10: 0, 0x7fffffffee38: 0x7fffffffefea, + 0x7ffff7e19ac0: 0, 0x7ffff7e19ac8: 0x405060, 0x405060: 0, 0x7ffff7ffd000: 0x7ffff7ffe3c0, 0x7ffff7ffe3c0: 0, + 0x403dc0: 0x401110, 0x404018: 0x405050, + # the heap: three chunks of 32, each a node (value, next), and the top + 0x405000: 0, 0x405008: 0x21, 0x405010: 7, 0x405018: 0, 0x405020: 0, 0x405028: 0x21, 0x405030: 0xc, + 0x405038: 0x405010, 0x405040: 0, 0x405048: 0x21, 0x405050: 9, 0x405058: 0x405030, 0x405068: 0x20fa1} +STRINGS = {0x7fffffffefea: "./list"} +WRITES = {33: {0x7fffffffece8: 0x401272}, 37: {0x7fffffffecd8: 0}, 44: {0x7fffffffecc8: 0x405030}, + 47: {0x405058: 0}, 49: {0x7fffffffecd8: 0x405050}, 51: {0x7fffffffecd0: 0x405030}, + 57: {0x7fffffffecc8: 0x405010}} + + +def mem(k): + m = dict(BASE) + for at in sorted(WRITES): + if at <= k: + m.update(WRITES[at]) + return m + + +def follow(v, m, depth=4): + """A chain from a value: (links, end) as context.chain takes them.""" + links = [] + while True: + ink = region(v) + if ink is None: + return links, ("int", v) + if ink == CODE: + return links + [(v, CODE, name(v))], None + links.append((v, ink)) + if v in STRINGS: + return links[:-1] + [links[-1]], ("str", STRINGS[v]) + if v not in m or len(links) > depth: + return links, None if v not in m else None + w = m[v] + if region(w) and w != v: + v = w + continue + return links, ("int", w) + + +# ---- the registers at each moment (ztrace show) ------------------------------------------------------------- +QUIET = ("rbx", "rdx", "rsi", "rdi", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15") # reverse moves rax rcx +FIXED = {"rbx": 0, "rdx": 0, "rsi": 0x405060, "rdi": 4, "r8": 0x7ffff7e19ac0, "r9": 0x20, "r10": 0x10, + "r11": 0x7ffff7e19ac8, "r12": 0x7fffffffee38, "r13": 1, "r14": 0x7ffff7ffd000, "r15": 0x403dc0} +MOVING = { # moment: rax, rcx, rbp, rsp, rip, eflags + 32: (0x405050, 0x405030, 0x7fffffffed00, 0x7fffffffecf0, 0x40126d, 0x202), + 33: (0x405050, 0x405030, 0x7fffffffed00, 0x7fffffffece8, 0x4011a0, 0x202), + 34: (0x405050, 0x405030, 0x7fffffffed00, 0x7fffffffece0, 0x4011a1, 0x202), + 35: (0x405050, 0x405030, 0x7fffffffece0, 0x7fffffffece0, 0x4011a4, 0x202), + 36: (0x405050, 0x405030, 0x7fffffffece0, 0x7fffffffecc8, 0x4011a8, 0x212), + 37: (0x405050, 0x405030, 0x7fffffffece0, 0x7fffffffecc8, 0x4011b0, 0x212), + 56: (0x405010, 0, 0x7fffffffece0, 0x7fffffffecc8, 0x4011ca, 0x206), + 57: (0x405010, 0, 0x7fffffffece0, 0x7fffffffecc8, 0x4011ce, 0x206), + 58: (0x405010, 0x405050, 0x7fffffffece0, 0x7fffffffecc8, 0x4011d2, 0x206), +} + + +def regs(k, pc, km=None): + """The registers after moment k's instruction ran, rip still on the instruction (mid-step: the mark goes last); + their chains through memory as of moment km (a register struck before the word it points at).""" + m = mem(k if km is None else km) + rax, rcx, rbp, rsp, _, _ = MOVING[k] + vals = dict(FIXED, rax=rax, rcx=rcx, rbp=rbp, rsp=rsp) + out = [] + for r in ("rax", "rbx", "rcx", "rdx", "rsi", "rdi", "rbp", "rsp", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"): + v = vals[r] + links, end = follow(v, m) if region(v) else ([], ("int", v)) + out.append((r, links, end)) + out.append(("rip", [(pc, CODE, name(pc))], None)) + return out + + +def flags(k, changed=()): + e = MOVING[k][5] + return [(f, e >> bit & 1, f in changed) for f, bit in (("CF", 0), ("PF", 2), ("AF", 4), ("ZF", 6), ("SF", 7), + ("IF", 9), ("DF", 10), ("OF", 11))] + + +# ---- the stack panel ------------------------------------------------------------------------------------------ +SLOT_ROLE = { # what the recording says each word is, per the pc's place in reverse (main's while the pc is there) + "reverse": {0x7fffffffecc8: "next", 0x7fffffffecd0: "cur", 0x7fffffffecd8: "prev", 0x7fffffffece0: "saved rbp", + 0x7fffffffed00: "saved rbp"}, + "prologue": {0x7fffffffecd0: "cur", 0x7fffffffecd8: "prev", 0x7fffffffece0: "saved rbp", 0x7fffffffed00: "saved rbp"}, + "entry": {0x7fffffffece0: "saved rbp", 0x7fffffffed00: "saved rbp"}, + "main": {0x7fffffffed00: "saved rbp"}, +} +NAMED = {"next", "cur", "prev"} # a local: primary; a saved register: dim + + +def stack_rows(k, top, n, rsp, rbp, marks=None, free=()): + """n slots from top. marks: {slot: {chain index: mark}}. free: slots drawn as not the frame's yet.""" + m = mem(k) + rows = [] + for i in range(n): + a = top + 8 * i + # rsp's pin stays on the window's top row: between rsp's strike and the slide it is there already + pins = [r for r, v in (("rbp", rbp), ("rsp", rsp)) if v == a or (r == "rsp" and i == 0 and v < a)] + w = m[a] + links, end = follow(w, m) if region(w) else ([], ("int", w)) + mk = dict((marks or {}).get(a, {})) + if mk and 1 in mk and not links: # a number written: the mark is on the value the chain ends in + mk = dict(mk) + mk["end"] = mk.pop(1) + if a in free: # not the frame's yet: its old word, faint, no chain + mk["free"] = True + links, end = [], ("int", w) + rows.append((a, pins, links, end, mk) if mk else (a, pins, links, end)) + return rows + + +def frames(top, n, newest): + """The spans: the newest frame's words to its return address, then main's, then libc's.""" + ends = [(newest[0], newest[1]), ("main", 0x7fffffffed08), ("libc+27781", 0x7fffffffed98)] if newest else \ + [("main", 0x7fffffffed08), ("libc+27781", 0x7fffffffed98)] + out, first = [], top + for nm, last in ends: + a, z = (first - top) // 8, (last - top) // 8 + out.append((nm, a, z)) + first = last + 8 + return out + + +# ---- the annotation, `tied` and `whole` ----------------------------------------------------------------------- +def note(g, x, y, parts): + """An annotation's runs: ("name", s, ink) bold, the place's name; ("addr", v, ink); ("int", v); ("points",); + ("holds",); ("text", s, ink); ("code", v) an address and its name. A run may end in a mark: "read" framed, + "strike" on the softened vermilion. Returns where it ends.""" + for p in parts: + kind, mk = p[0], p[-1] if p[-1] in ("read", "strike") else None + if kind == "points": + x = C.link_arrow(g, x, y) + continue + if kind == "holds": + x = C.value_arrow(g, x, y) + continue + if kind == "name": + s_, ink, face = p[1], p[2], BOLD + elif kind == "addr": + s_, ink, face = "%x" % p[1], p[2], MONO + elif kind == "int": + s_, ink, face = (str(p[1]) if p[1] < 10 else "0x%x" % p[1]), VELLUM, MONO + elif kind == "code": + s_, ink, face = "%x" % p[1], CODE, MONO + else: + s_, ink, face = p[1], p[2], MONO + w = len(s_) * A + if mk == "strike": + g.t(x, b(y), s_, S, C.struck(g, x - 5, y, w + 10), BOLD) + else: + if mk == "read": + g.frame(x - 6, y, w + 12, ROW, READ, 2) + g.t(x, b(y), s_, S, ink, face) + x += w + if kind == "code": + g.t(x + 10, b(y), name(p[1]), S, VELLUM, MONO) + x += 10 + len(name(p[1])) * A + x += 0 + return x + + +def place(form, nm, addr_, links, end, mk=None): + """What a row says of a word it reads or writes. `tied`: the word's name (its role) where the stack pane holds + it, then the value, one hop. `whole`: the address and the chain, as the catalogue had it.""" + if form == "tied" and nm: + out = [("name", nm, STACK, "read") if mk == "read" else ("name", nm, STACK)] + else: + out = [("addr", addr_, region(addr_), "read") if mk == "read" else ("addr", addr_, region(addr_))] + hops = links if form == "whole" else links[:1] + for i, h in enumerate(hops): + out.append(("points",)) + last = i == len(hops) - 1 + if h[1] == CODE: + out.append(("code", h[0])) + else: + out.append(("addr", h[0], h[1], "strike") if mk == "strike" and i == 0 else ("addr", h[0], h[1])) + if end is not None and (form == "whole" or not links): + out.append(("holds",)) + out.append(("int", end[1], "strike") if mk == "strike" and not links else ("int", end[1])) + return out + + +def carry(g, ya, yb): + """`carry`: a value's way from a word to a register or back, both in the state column: out of the source's + panel at its left rule, along the gutter's right lane (x 962), into the destination's rule; 2 units in primary, + its head an open chevron, so that it is never a link (3 units, the region's ink, a filled head, a pin).""" + gen.arrow(g, [(976, ya), (962, ya), (962, yb), (975, yb)], VELLUM, 2, r=6, head=False) + g.path(f"M{968},{yb - 5} L{975},{yb} L{968},{yb + 5}", VELLUM, 2, join="miter") + + +def touch(g, y_row, y_slot, ink): + """`touch`: the current row, across the gutter's middle lane, to the stack's rule level with its word.""" + gen.arrow(g, [(944, y_row + 12), (956, y_row + 12), (956, y_slot + 12), (978, y_slot + 12)], ink, 2, r=6, + hl=7, hw=8) + + +# ---- the minimaps: each pane's column from what the recording holds ------------------------------------- +def strips(g, bx, src_first, src_cur, dis_rows_all, dis_first, ndis, pc, stack_top, words, slots_all_top): + src_rows = [[(64 + (len(l) - len(l.lstrip())) * A, len(l.strip()) * A, VELLUM)] if l.strip() else [] + for l in SRC[:44]] + F.strip(g, *F.strip_at(bx["source"]), src_rows, src_first - 1, 8, {src_cur - 1: "current"}) + col = [[(40, 6 * A, CODE), (180, len(mn) * A, gen.KW), (264, len(ops) * A, VELLUM)] for a, ln, mn, ops in dis_rows_all] + c0 = [r[0] for r in dis_rows_all] + F.strip(g, *F.strip_at(bx["disasm"]), col, c0.index(dis_first), ndis, {c0.index(pc): "current"}) + m = mem(57) + stk = [] + for i in range(48): + a = slots_all_top + 8 * i + w = m.get(a, 0) + stk.append([(184, 12 * A, STACK)] + ([(184 + 13 * A, 12 * A, region(w) or VELLUM)] if w else [(184 + 13 * A, A, FAINT)])) + F.strip(g, *F.strip_at(bx["stack"]), stk, (stack_top - slots_all_top) // 8, words) + + +ALL_DIS = [(a, ln, mn, ops if isinstance(ops, str) else "%x" % ops) for a, ln, mn, ops in + [(0x401150 + 4 * i, 11, "mov", "rax, rbx") for i in range(0)] + REV + DIS] +ALL_DIS.sort() + + +def ops_parts(ops): + if isinstance(ops, int): # a call's or jump's target: by its symbol where it is one + return [((ops, SYMS[ops]), CODE)] if ops in SYMS else [(ops, CODE)] + return [(ops, VELLUM)] if ops else [] + + +def dis_window(pc, n, states, notes, rows=None): + rows = rows or REV + i = [r[0] for r in rows].index(pc) + lo = max(0, min(i - n // 2, len(rows) - n)) + out = [] + for a, ln, mn, ops in rows[lo:lo + n]: + out.append((a, ln, mn, ops_parts(ops), states.get(a), None)) + return out, [r[0] for r in rows[lo:lo + n]] + + +# ---- a frame of the loop: the store (56 to 57) and the load (57 to 58) ----------------------------------- +def loop_frame(g, step, form, way=None, ov=None): + """step: "store" (4011ca, next = cur->next) or "load" (4011ce, rcx = prev). form: "tied" or "whole". + way: the sheet's alternatives, "A" (names, echo, pwndbg's offsets), "B" (= tied), "C" (the name in the operand). + ov: an instant of the step before its hold (the carry strip): which marks, ties and moments it has reached.""" + M.stage(False) + ov = ov or {} + k, pc = (57, 0x4011ca) if step == "store" else (58, 0x4011ce) + line = 21 if step == "store" else 22 + rax, rcx, rbp, rsp, _, _ = MOVING[k] + tied = form == "tied" + bx, nregs, words = F.boxes("subject", "A", QUIET) + src, dis = (bx["source"][2] - 32) // ROW, (bx["disasm"][2] - 32) // ROW + m = mem(k) + + # the program column + M.strip(True) + C.LX = 64 + ys = C.source(g, bx["source"][1], src, SRC, 18, line, [21] if step == "load" else [20], "list.c", 44) + trail = {"store": {0x4011c6: "trail0", 0x4011c2: "trail1", 0x4011c0: "trail2", 0x4011ca: "cur"}, + "load": {0x4011ca: "trail0", 0x4011c6: "trail1", 0x4011c2: "trail2", 0x4011ce: "cur"}}[step] + rows, shown = dis_window(pc, dis, trail, {}) + if way == "C": # the name in the operand, as a reverse-engineering tool writes it + rows = [(a, ln, mn, [(o.replace("qword ptr [rbp - 0x18]", "[rbp+next]").replace("qword ptr [rbp - 0x10]", "[rbp+cur]") + .replace("qword ptr [rbp - 8]", "[rbp+prev]"), VELLUM) if isinstance(o, str) else (o, ink) + for o, ink in ops], st, nt) for a, ln, mn, ops, st, nt in rows] + at = C.disasm(g, bx["disasm"][1], rows, "reverse", line) + if way == "C": # the names in the operands in the stack's ink, bold, over the plain text + for a, ln, mn, ops, st, nt in rows: + for o, ink in ops: + if isinstance(o, str): + for nm in ("next", "cur", "prev"): + j = o.find("+" + nm + "]") + if j >= 0: + g.rect(64 + C.DX_OPS + (j + 1) * A, at[a] + 3, len(nm) * A, ROW - 6, mix(BRIGHT, PAGE, 0.1) + if st == "cur" else PAGE) + g.t(64 + C.DX_OPS + (j + 1) * A, b(at[a]), nm, S, STACK, BOLD) + + # each row's annotation: the trail's and the current row's + nx = 64 + C.DX_NOTE + slot_name = {0x7fffffffecc8: "next", 0x7fffffffecd0: "cur", 0x7fffffffecd8: "prev"} + name_for = (lambda a: None) if way == "A0" else (lambda a: slot_name.get(a)) + f = form if way != "C" else "tied" + + def access(a, slot, mk=None, heap=False): + w = m[slot] if not (step == "store" and slot == 0x7fffffffecc8 and a == 0x4011c2) else m[slot] + links, end = follow(w, m) if region(w) else ([], ("int", w)) + if f == "whole": # the catalogue's: the chain from the address, cut where the row ends + C.chain(g, nx, at[a], [(slot, region(slot))] + links, end, {0: mk} if mk == "read" else + ({1: "strike"} if mk == "strike" else None), room=64 + C.CW - 12) + return + if way == "C" and not heap: # the operand named it: the row says only what moved + parts = place("tied", None, slot, links, end, mk)[1:] + else: + parts = place(f, None if heap else name_for(slot), slot, links, end, mk) + note(g, nx, at[a], parts) + + if step == "store": + note(g, nx, at[0x4011c0], [("text", "not taken", DIM), ("text", " · reads ", FAINT), ("text", "zf", DIM)]) + access(0x4011c2, 0x7fffffffecd0) + hm = dict(m) + access(0x4011c6, 0x405038, heap=True) + access(0x4011ca, 0x7fffffffecc8, ov.get("note_mark", "strike")) + else: + access(0x4011c6, 0x405038, heap=True) + access(0x4011c2, 0x7fffffffecd0) + access(0x4011ca, 0x7fffffffecc8) + access(0x4011ce, 0x7fffffffecd8, ov.get("note_mark", "read")) + M.strip(False) + + # the state column + C.RX = 976 + reg_marks = ov.get("reg_marks", {"rax": {0: "tick"}, "rcx": {0: "strike"} if step == "load" else {}}) + where = C.registers(g, bx["registers"][1], regs(ov.get("k_regs", k), pc), flags(k), reg_marks, QUIET) + M.strip(True) + C.RX = 976 + top = rsp + smarks = ov.get("smarks", {0x7fffffffecc8: {1: "strike"}} if step == "store" else {0x7fffffffecd8: {1: "read"}, + 0x7fffffffecc8: {1: "tick"}}) + roles = {i: (r, VELLUM if r in NAMED else DIM) for i in range(words) + for r in [SLOT_ROLE["reverse"].get(top + 8 * i)] if r} + base_off = rbp if (tied and way != "A") else rsp + sy = C.stack(g, bx["stack"][1], stack_rows(ov.get("k_mem", k), top, words, rsp, rbp, smarks), + frames(top, words, ("reverse", 0x7fffffffece8)), + note="%s words · offsets from %s" % (F.WORDS[words], "rbp" if base_off == rbp else "rsp"), + rsp=base_off, roles=roles) + M.strip(False) + + # the band: the list, three nodes in the order the program made them, and the heap they are + vr = C.fields(g, TOP, 200, "the heap, 405000 to 40506f", 0x405000, 112, heap_fields(), heap_bytes(k), HEAP, region, + rows_shown=list(range(7)), more_rows=False) + nodes = [(0x405050, 9, m[0x405058]), (0x405030, 12, m[0x405038]), (0x405010, 7, m[0x405018])] + # names keep their side: head and prev came first (left of 9's stub), rcx takes the free side + pins = {0x405050: ["head prev"] + (["rcx"] if step == "load" and ov.get("link", True) else []), 0x405030: ["cur"], + 0x405010: ["rax"] + (["next"] if step == "load" or ov.get("pins_after", True) else [])} + C.RX, C.LX = 976, 64 + C.lens(g, TOP, 296, 200, nodes, pins, {}, 0x405000, 7, + link_from=(where["rcx"], "rcx") if step == "load" and ov.get("link", True) else None, + subject=True, view_rows=vr) + C.thread(g, ys, [(at[pc], at[pc] + ROW)]) + + # the tie between the row and its word + slot = 0x7fffffffecc8 if step == "store" else 0x7fffffffecd8 + if tied and way in (None, "B") and ov.get("touch", True): + touch(g, at[pc], sy[(slot - top) // 8], VERM if step == "store" else READ) + for name_, kind in ov.get("reg_frames", {}).items(): # a register framed as read, or armed, by hand + v = regs(ov.get("k_regs", k), pc)[[r[0] for r in regs(k, pc)].index(name_)] + w_ = len("%x" % v[1][0][0]) * A if v[1] else len(str(v[2][1])) * A + g.frame(976 + 72 - 6 if kind == "read" else 976 + 72 - 5, where[name_], w_ + 12 if kind == "read" else w_ + 10, + ROW, READ if kind == "read" else VERM, 2) + if ov.get("carry"): # the carry: a value's way between a word and a register + src, dst = ov["carry"] + ya = (sy[(src - top) // 8] if isinstance(src, int) else where[src]) + 12 + yb = (sy[(dst - top) // 8] if isinstance(dst, int) else where[dst]) + 12 + carry(g, ya, yb) + strips(g, bx, 18, line, ALL_DIS, shown[0], dis, pc, top, words, top - 16 * 8) + M.clock(g, k - 32, 70) + return bx, at, sy + + +def heap_fields(): + out = [] + for a in (0x405010, 0x405030, 0x405050): + out += [(a - 8 - 0x405000, 8, "malloc", False, None), (a - 0x405000, 8, "number", False, None), + (a + 8 - 0x405000, 8, "pointer", False, None)] + out.append((0x405068 - 0x405000, 8, "malloc", False, None)) + return out + + +def heap_bytes(k): + m = mem(k) + out = {} + for a in range(0x405000, 0x405070, 8): + for i in range(8): + out[a + i] = m.get(a, 0) >> (8 * i) & 0xff + return out + + +CAP = { + "store": [[("next = cur->next", "mono"), (": the word at ", ), ("[rbp - 0x18]", "mono"), (" is ", ), ("next", "mono"), + (",", )], [("and it now holds 405010, the node whose value is 7.", )]], + "load": [[("cur->next = prev", "mono"), (" begins by reading ", ), ("prev", "mono"), (" into ", ), ("rcx", "mono"), + (":", )], [("405050, the node of 9, which the first turn reversed.", )]], +} + + +def save(name_, draw, *a, **kw): + gen.W, gen.H = 1920, 1080 + g = Svg() + out = draw(g, *a, **kw) + g.save(name_) + subprocess.run(["resvg", HERE + "/" + name_ + ".svg", HERE + "/" + name_ + ".png"], check=True) + return out + + +def full(g, step, form): + loop_frame(g, step, form) + gen.caption(g, CAP[step]) + + +FONT = lambda n, s: ImageFont.truetype("/usr/share/fonts/go/%s.ttf" % n, s) + + +def pair_sheet(out, step): + """The same instant as the catalogue had it (`whole`) over `tied`, each a whole frame.""" + parts = [] + for form in ("whole", "tied"): + nm = "tmp-%s-%s" % (step, form) + save(nm, full, step, form) + parts.append((form, Image.open(HERE + "/" + nm + ".png").convert("RGB"))) + head = 72 + s = Image.new("RGB", (1920, 2 * (1080 + head)), "#0a1030") + d = ImageDraw.Draw(s) + labels = {"whole": ("whole", "the annotation as it was: the address, the chain; the stack's offsets from rsp", "#eee6d2"), + "tied": ("tied", "the place's name and the value; offsets from the frame's base; the touch", "#e8c46a")} + for i, (form, im) in enumerate(parts): + y = i * (1080 + head) + t, sub, ink = labels[form] + d.text((64, y + 18), t, font=FONT("Go-Medium", 34), fill=ink) + d.text((64 + 150, y + 28), sub, font=FONT("Go-Regular", 24), fill="#9aa6d9") + s.paste(im, (0, y + head)) + s.save(HERE + "/" + out) + for form in ("whole", "tied"): + for ext in ("svg", "png"): + subprocess.run(["rm", "-f", "%s/tmp-%s-%s.%s" % (HERE, step, form, ext)], check=True) + + +# ---- the stack's own instructions: a strip of instants ------------------------------------------------- +def stack_step(g, inst): + """One instant of a stack instruction's step, `tied`: the program column's disassembly and the state column, + the band left out (the strips are cut below it).""" + M.stage(False) + k, pc, line, func, trail, notes, rmarks, smarks, top, words_off, newest, free, touch_to, rcol = inst + k, km = k if isinstance(k, tuple) else (k, k) # the registers' moment, and memory's + bx, nregs, words = F.boxes("subject", "A", QUIET) + src, dis = (bx["source"][2] - 32) // ROW, (bx["disasm"][2] - 32) // ROW + rax, rcx, rbp, rsp, _, _ = MOVING[k] + M.strip(True) + C.LX = 64 + first = max(1, line - 4) + ys = C.source(g, bx["source"][1], src, SRC, first, line, [], "list.c", 44) + rows_src = DIS if func == "main" else REV + rows, shown = dis_window(pc, dis, trail, {}, rows_src) + at = C.disasm(g, bx["disasm"][1], rows, func, line) + for a, parts in notes.items(): + if a in at: + note(g, 64 + C.DX_NOTE, at[a], parts) + M.strip(False) + C.RX = 976 + C.registers(g, bx["registers"][1], regs(k, pc, km), flags(k), rmarks, QUIET) + M.strip(True) + C.RX = 976 + roles_map = SLOT_ROLE[newest[2]] if newest else SLOT_ROLE["main"] + roles = {i: (r, VELLUM if r in NAMED else DIM) for i in range(words) for r in [roles_map.get(top + 8 * i)] if r} + base, base_name = words_off + sy = C.stack(g, bx["stack"][1], stack_rows(km, top, words, rsp, rbp, smarks, free), + frames(top, words, newest[:2] if newest else None), + note="%s words · offsets from %s" % (F.WORDS[words], base_name), rsp=base, roles=roles) + M.strip(False) + C.thread(g, ys, [(at[pc], at[pc] + ROW)]) + if touch_to: + touch(g, at[pc], sy[(touch_to - top) // 8], rcol) + strips(g, bx, first, line, ALL_DIS, shown[0], dis, pc, top, words, top - 16 * 8) + return bx + + +RA = 0x7fffffffece8 +HEADROOM = 2 # free words the window keeps over rsp at rest + + +def pinned_rows(km, top, n, pins_at, marks, free, count=None): + """Rows with the pins where the instant has them (mid-travel they are not where the registers say yet), a + travelling pin's amount after its name.""" + m = mem(km) + rows = [] + for i in range(n): + a = top + 8 * i + pins = [r for r in ("rbp", "rsp") if pins_at.get(r) == a] + pins = sum(([r, (count or {})[r]] if r in (count or {}) else [r] for r in pins), []) + w = m[a] + links, end = follow(w, m) if region(w) else ([], ("int", w)) + mk = dict((marks or {}).get(a, {})) + if mk and 1 in mk and not links: + mk["end"] = mk.pop(1) + if a in free: + mk["free"] = True + links, end = [], ("int", w) + rows.append((a, pins, links, end, mk) if mk else (a, pins, links, end)) + return rows + + +def ghost_pin(g, y, names, k, after=0): + """Where a travelling pin was, a few frames apart (the mock's onion skin: the render moves one pin). after: + the characters of a pin standing on that row, which keeps its place (names keep their order).""" + ink, head = mix(VELLUM, PAGE, k), mix(STACK, PAGE, k) + s_ = " ".join(names) + x0 = 976 + 16 + (after + 2 if after else 0) * A + g.t(x0, b(y), s_, S, ink, BOLD) + x = x0 + len(s_) * A + 5 + if not after: + g.path(f"M{x + 9},{y + 12} l-9,-6 v12 Z", fill=head) + + +def travel_step(g, d): + """One instant of a step that moves rsp or rbp, `tied`: the row fires, the register strikes, the pin travels + over the rows (they change state as it passes: gained, released), the span with it, its amount on it; then + the touch and the word; the window follows only after the pin has landed.""" + M.stage(False) + k, km = d["k"] + pc, line, func = d["pc"], d["line"], d["func"] + bx, nregs, words = F.boxes("subject", "A", QUIET) + src, dis = (bx["source"][2] - 32) // ROW, (bx["disasm"][2] - 32) // ROW + M.strip(True) + C.LX = 64 + first = max(1, line - 4) + ys = C.source(g, bx["source"][1], src, SRC, first, line, [], "list.c", 44) + rows, shown = dis_window(pc, dis, d["trail"], {}, DIS if func == "main" else REV) + at = C.disasm(g, bx["disasm"][1], rows, func, line) + for a, parts in d["notes"].items(): + if a in at: + note(g, 64 + C.DX_NOTE, at[a], parts) + M.strip(False) + C.RX = 976 + C.registers(g, bx["registers"][1], regs(k, pc, km), flags(k), d.get("rmarks", {}), QUIET) + M.strip(True) + C.RX = 976 + top = d["top"] + roles_map = SLOT_ROLE[d["roles"]] + roles = {i: (r, VELLUM if r in NAMED else DIM) for i in range(words) for r in [roles_map.get(top + 8 * i)] + if r and top + 8 * i not in d.get("free", ())} + base, base_name = d["base"] + sp = [] + if d.get("newest"): + nm, ra, start = d["newest"] + sp.append((nm, (start - top) // 8, (ra - top) // 8)) + first_main = (d["newest"][1] + 8) if d.get("newest") else d["main_from"] + sp += [("main", (first_main - top) // 8, (0x7fffffffed08 - top) // 8), + ("libc+27781", (0x7fffffffed10 - top) // 8, (0x7fffffffed98 - top) // 8)] + sy = C.stack(g, bx["stack"][1], pinned_rows(km, top, words, d["pins"], d.get("smarks"), d.get("free", ()), + d.get("count")), + sp, note="%s words · offsets from %s%s" % (F.WORDS[words], base_name, d.get("tagnote", "")), + rsp=base, roles=roles) + M.strip(False) + row_y = lambda a: sy[(a - top) // 8] + for a, names, kk in d.get("ghosts", ()): # the pin's path, a few frames apart + standing = [n for n in ("rbp", "rsp") if d["pins"].get(n) == a] + ghost_pin(g, row_y(a), names, kk, len(" ".join(standing)) if standing else 0) + if d.get("travel"): # the rows the pin crossed: gained or released + a0, a1 = sorted(d["travel"]) + C.bracket(g, 976 + 5, row_y(a0) + 2, row_y(a1) + ROW - 2, VERM, 3, 5) + for r, cnt in d.get("count", {}).items(): # the amount, on the pin while it travels: in write's ink + y = row_y(d["pins"][r]) + names = [n for n in ("rbp", "rsp") if d["pins"].get(n) == d["pins"][r]] + x = 976 + 16 + (len(" ".join(names)) + 1) * A + g.rect(x - 1, y + 3, len(cnt) * A + 2, ROW - 6, PAGE) + g.t(x, b(y), cnt, S, VERM, BOLD) + if d.get("arm"): + a = d["arm"] + g.frame(976 + 184 + 12 * A + 30 - 5, row_y(a), 12 * A + 10, ROW, VERM, 2) + C.thread(g, ys, [(at[pc], at[pc] + ROW)]) + if d.get("touch"): + touch(g, at[pc], row_y(d["touch"][0]), d["touch"][1]) + strips(g, bx, first, line, ALL_DIS, shown[0], dis, pc, top, words, top - 16 * 8) + return bx + + +STATIC_CALL = {0x40126d: [("text", "reverse", BRIGHT), ("text", "()", VELLUM), ("text", " · ", FAINT), + ("text", "rsp ", DIM), ("text", "-8", VELLUM)]} +STRUCK_CALL = {0x40126d: [("text", "reverse", BRIGHT), ("text", "()", VELLUM), ("text", " · ", FAINT), + ("text", "rsp ", DIM), ("text", "-8", VELLUM, "strike")]} +ECF0, ECE8, ECE0 = 0x7fffffffecf0, 0x7fffffffece8, 0x7fffffffece0 +MAIN_TRAIL = {0x401268: "trail0", 0x40126d: "cur"} +CALL_BASE = dict(pc=0x40126d, line=41, func="main", trail=MAIN_TRAIL, roles="main", main_from=ECF0) +CALL = [ + ("1", "0 to 12", "fire on the call", "the cause, alone: the plaque pulses; the row says what the call will do, " + "reverse() and rsp -8; two free words stand over rsp, where the push will land", + dict(CALL_BASE, k=(32, 32), notes=STATIC_CALL, top=ECE0, pins={"rsp": ECF0, "rbp": 0x7fffffffed00}, + free={ECE0, ECE8}, base=(0x7fffffffed00, "rbp"))), + ("2", "18 to 30", "the touch", "from the call row across the gutter to the word the call will write, rsp - 8, still " + "free; nothing else has moved", + dict(CALL_BASE, k=(32, 32), notes=STATIC_CALL, top=ECE0, pins={"rsp": ECF0, "rbp": 0x7fffffffed00}, + free={ECE0, ECE8}, base=(0x7fffffffed00, "rbp"), touch=(ECE8, VERM))), + ("3", "30 to 42", "the word", "only now that the touch has landed: the word armed (30), struck (42): the return " + "address, main+50, the row after the call. rsp has not moved", + dict(CALL_BASE, k=(32, 33), notes=STATIC_CALL, top=ECE0, pins={"rsp": ECF0, "rbp": 0x7fffffffed00}, + free={ECE0}, smarks={ECE8: {1: "strike"}}, base=(0x7fffffffed00, "rbp"), touch=(ECE8, VERM))), + ("4", "48 to 72", "rsp's pin climbs onto it", "then what follows from the word: rsp's pin travels up onto it, 24 f, " + "glide (its old place drawn faint), -8 on it, the bracket over the word gained; reverse's span grows with it, " + "gold, main's going to rule; the offsets count from rsp; as the pin lands, rsp is struck, and the row's -8 with it", + dict(CALL_BASE, k=(33, 33), notes=STRUCK_CALL, rmarks={"rsp": {0: "strike"}}, smarks={ECE8: {1: "strike"}}, + top=ECE0, pins={"rsp": ECE8, "rbp": 0x7fffffffed00}, free={ECE0}, base=(ECE8, "rsp"), roles="entry", + newest=("reverse", ECE8, ECE8), count={"rsp": "-8"}, ghosts=[(ECF0, ["rsp"], 0.75)], travel=(ECE8, ECE8), + touch=(ECE8, VERM))), + ("5", "78 to 102", "the window follows", "last, the pin landed: the rows glide down one slot, 24 f, so that two " + "free words stand over rsp again; the pin rides its row. Hold, then the advance (the plaque to reverse's first " + "row, the touch drawn back)", + dict(CALL_BASE, k=(33, 33), notes=STRUCK_CALL, rmarks={"rsp": {0: "strike"}}, smarks={ECE8: {1: "strike"}}, + top=0x7fffffffecd8, pins={"rsp": ECE8, "rbp": 0x7fffffffed00}, free={0x7fffffffecd8, ECE0}, + base=(ECE8, "rsp"), roles="entry", newest=("reverse", ECE8, ECE8), tagnote=" · followed 1", + touch=(ECE8, VERM))), +] +ECC8, ECD0, ECD8 = 0x7fffffffecc8, 0x7fffffffecd0, 0x7fffffffecd8 +PUSHN = [("text", "rsp ", DIM), ("text", "-8", VELLUM), ("text", " · ", FAINT), ("name", "saved rbp", STACK)] +MOVN = [("text", "rbp", DIM), ("text", " = ", FAINT), ("text", "rsp", DIM)] +SUBN = [("text", "rsp ", DIM), ("text", "-0x18", VELLUM), ("text", " 3 words", FAINT)] +REVB = dict(func="reverse", line=17) +PROLOGUE = [ + ("1", "push rbp · 0 to 30", "fire; the touch", "the row fires; the touch runs to the word over rsp, free; " + "nothing else has moved", + dict(REVB, k=(33, 33), pc=0x4011a0, trail={0x4011a0: "cur"}, notes={0x4011a0: PUSHN}, top=ECD8, + pins={"rsp": ECE8, "rbp": 0x7fffffffed00}, free={ECD8, ECE0}, base=(ECE8, "rsp"), roles="main", + newest=("reverse", ECE8, ECE8), touch=(ECE0, VERM))), + ("2", "30 to 42", "the word written", "armed: rbp's value, 7fffffffed00, is what the word held already, so the " + "arm's frame comes and goes and nothing is struck; the word is the frame's now, no longer faint", + dict(REVB, k=(33, 34), pc=0x4011a0, trail={0x4011a0: "cur"}, notes={0x4011a0: PUSHN}, top=ECD8, + pins={"rsp": ECE8, "rbp": 0x7fffffffed00}, free={ECD8}, base=(ECE8, "rsp"), roles="main", + newest=("reverse", ECE8, ECE8), touch=(ECE0, VERM), arm=ECE0)), + ("3", "48 to 72", "rsp's pin climbs onto it", "rsp's pin travels up a row onto the word, -8 on it, the bracket over " + "it; the span stretches with the pin; the role arrives, saved rbp; rsp struck as the pin lands, the row's -8 " + "with it. The window then follows (78 to 102)", + dict(REVB, k=(34, 34), pc=0x4011a0, trail={0x4011a0: "cur"}, + notes={0x4011a0: [PUSHN[0], ("text", "-8", VELLUM, "strike")] + PUSHN[2:]}, rmarks={"rsp": {0: "strike"}}, + top=ECD8, pins={"rsp": ECE0, "rbp": 0x7fffffffed00}, free={ECD8}, base=(ECE0, "rsp"), roles="entry", + newest=("reverse", ECE8, ECE0), count={"rsp": "-8"}, ghosts=[(ECE8, ["rsp"], 0.75)], travel=(ECE0, ECE0), + touch=(ECE0, VERM))), + ("4", "mov rbp, rsp · 18 to 48", "rbp flies to rsp", "the row fires; rbp's pin leaves main's saved rbp and flies up " + "the lane, 30 f, to rsp's row, where the two meet (rsp slides aside, pwndbg's order); rbp struck as it lands; " + "the offsets' base becomes rbp, and no digit changes, since rbp is rsp", + dict(REVB, k=(35, 35), pc=0x4011a1, trail={0x4011a0: "trail0", 0x4011a1: "cur"}, + notes={0x4011a0: PUSHN, 0x4011a1: MOVN + [("text", " ", FAINT), ("addr", 0x7fffffffece0, STACK, "strike")]}, + rmarks={"rbp": {0: "strike"}, "rsp": {0: "tick"}}, top=ECD0, pins={"rsp": ECE0, "rbp": ECE0}, + free={ECD0, ECD8}, base=(ECE0, "rbp"), roles="entry", newest=("reverse", ECE8, ECE0), + ghosts=[(0x7fffffffed00, ["rbp"], 0.8), (0x7fffffffecf8, ["rbp"], 0.7), (0x7fffffffecf0, ["rbp"], 0.6), + (ECE8, ["rbp"], 0.5)])), + ("5", "sub rsp, 0x18 · 18 to 42", "the climb", "the row fires; rsp's pin climbs, the amount counting on it; each row " + "it reaches is gained (it brightens from free, 12 f, and its role arrives, prev), the bracket and the span " + "growing under it; here at its first row, -8", + dict(REVB, k=(35, 35), pc=0x4011a4, trail={0x4011a0: "trail1", 0x4011a1: "trail0", 0x4011a4: "cur"}, + notes={0x4011a0: PUSHN, 0x4011a1: MOVN, 0x4011a4: SUBN}, rmarks={"rbp": {0: "tick"}}, + top=ECD0, pins={"rsp": ECD8, "rbp": ECE0}, free={ECD0}, base=(ECE0, "rbp"), roles="prologue", + newest=("reverse", ECE8, ECD8), count={"rsp": "-8"}, ghosts=[(ECE0, ["rsp"], 0.75)], travel=(ECD8, ECD8))), + ("6", "42 to 60", "landed, followed", "three rows up, -18: cur's row and the one above gained; the two free words " + "were not room enough, so for the last of the climb the rows slid down under the pin, one move; rsp struck as " + "it lands, the row's -0x18 with it; two free words over rsp again", + dict(REVB, k=(36, 36), pc=0x4011a4, trail={0x4011a0: "trail1", 0x4011a1: "trail0", 0x4011a4: "cur"}, + notes={0x4011a0: PUSHN, 0x4011a1: MOVN, 0x4011a4: [SUBN[0], ("text", "-0x18", VELLUM, "strike"), SUBN[2]]}, + rmarks={"rsp": {0: "strike"}, "rbp": {0: "tick"}}, top=ECC8 - 16, pins={"rsp": ECC8, "rbp": ECE0}, + free={ECC8 - 16, ECC8 - 8}, base=(ECE0, "rbp"), roles="prologue", newest=("reverse", ECE8, ECC8), + count={"rsp": "-18"}, ghosts=[(ECE0, ["rsp"], 0.8), (ECD8, ["rsp"], 0.7), (ECD0, ["rsp"], 0.6)], + travel=(ECC8, ECD8))), +] + + +def strip_sheet(out, title, sub, instants, y0=336, y1=892): + """Instants of one step, each the frame cut to the rows it moves: the registers' moving rows, the stack, the + source's foot and the disassembly.""" + ims = [] + for i, (num, when, what, why, inst) in enumerate(instants): + when = num + " " + when + nm = "tmp-strip-%d" % i + save(nm, travel_step, inst) + ims.append((when, what, why, Image.open(HERE + "/" + nm + ".png").convert("RGB").crop((0, y0, 1920, y1)))) + for ext in ("svg", "png"): + subprocess.run(["rm", "-f", "%s/%s.%s" % (HERE, nm, ext)], check=True) + head, lab = 110, 104 + h = y1 - y0 + s = Image.new("RGB", (1920, head + len(ims) * (h + lab)), "#0a1030") + d = ImageDraw.Draw(s) + d.text((64, 26), title, font=FONT("Go-Medium", 34), fill="#fff8e8") + d.text((64, 70), sub, font=FONT("Go-Regular", 22), fill="#9aa6d9") + for i, (when, what, why, im) in enumerate(ims): + y = head + i * (h + lab) + d.text((64, y + 8), when, font=FONT("Go-Medium", 26), fill="#e8c46a") + x_ = 64 + d.textlength(when, font=FONT("Go-Medium", 26)) + 24 + d.text((x_, y + 8), what, font=FONT("Go-Medium", 26), fill="#eee6d2") + f20, lines_, cur = FONT("Go-Regular", 20), [], "" + for w_ in why.split(): + if d.textlength(cur + " " + w_, font=f20) > 1790 and cur: + lines_.append(cur) + cur = w_ + else: + cur = (cur + " " + w_).strip() + lines_.append(cur) + for j, l_ in enumerate(lines_[:2]): + d.text((64, y + 44 + 26 * j), l_, font=f20, fill="#9aa6d9") + s.paste(im, (0, y + lab)) + s.save(HERE + "/" + out) + + +# ---- the sheet: three ways to show the relation ------------------------------------------------------------ +def ways(out): + ways_ = [("A", "echo", "names, and the same mark in both at once; no line; pwndbg's offsets from rsp", "#eee6d2"), + ("B", "touch (recommended: the `tied` form)", "names; offsets from the frame's base, the operand's own digits; " + "for the walked step a line from the row to its word", "#e8c46a"), + ("C", "operand", "the name in the operand, as IDA writes it; the row says only what moved; offsets from rbp; " + "no line", "#eee6d2")] + y0, y1 = 508, 892 + ims = [] + for key, t, sub, ink in ways_: + nm = "tmp-way-%s" % key + save(nm, lambda g, k=key: loop_frame(g, "store", "tied", k)) + ims.append((key, t, sub, ink, Image.open(HERE + "/" + nm + ".png").convert("RGB").crop((0, y0, 1920, y1)))) + for ext in ("svg", "png"): + subprocess.run(["rm", "-f", "%s/%s.%s" % (HERE, nm, ext)], check=True) + head, lab = 120, 70 + h = y1 - y0 + s = Image.new("RGB", (1920, head + len(ims) * (h + lab)), "#0a1030") + d = ImageDraw.Draw(s) + d.text((64, 26), "The row and its word: three ways to say they are one thing", font=FONT("Go-Medium", 34), fill="#fff8e8") + d.text((64, 72), "The same instant: next = cur->next stored (mov [rbp - 0x18], rax), mid-step, its strike on the stack. " + "The disassembly and the stack, cut from the frame.", font=FONT("Go-Regular", 22), fill="#9aa6d9") + for i, (key, t, sub, ink, im) in enumerate(ims): + y = head + i * (h + lab) + d.text((64, y + 16), key, font=FONT("Go-Bold", 30), fill=ink) + d.text((104, y + 16), t, font=FONT("Go-Medium", 28), fill=ink) + d.text((104, y + 50 - 4), sub, font=FONT("Go-Regular", 20), fill="#9aa6d9") + s.paste(im, (0, y + lab)) + if key == "B": + d.rectangle((0, y + lab - 2, 1919, y + lab + h + 1), outline="#e8c46a", width=2) + s.save(HERE + "/" + out) + + +CARRY = [ # (number, frames, what, why, step, overrides) + ("1", "load · 18 to 36", "the touch, the read", "mov rcx, [rbp - 8] fired (0 to 12); the touch runs from the row to " + "prev's word (18 to 30) and, landed, the word is framed read with the row's prev (30 to 36). rcx not yet", + "load", dict(k_regs=57, reg_marks={"rax": {0: "tick"}}, link=False)), + ("2", "36 to 60", "the carry", "the touch draws back as the carry leaves the word: along the gutter's right lane up " + "to rcx's row, head first (24 f), an open chevron in primary; as it lands rcx is armed (48 to 60)", + "load", dict(k_regs=57, reg_marks={"rax": {0: "tick"}}, link=False, touch=False, + carry=(0x7fffffffecd8, "rcx"), reg_frames={"rcx": "arm"})), + ("3", "60 to 90", "struck, and what follows", "rcx struck (60); the carry draws back (18 f); then what follows " + "from the new value: rcx's link climbs to its pin under 9's node (66 to 90)", + "load", dict(touch=False)), + ("4", "store · 18 to 24", "the source read", "mov [rbp - 0x18], rax fired; its source, rax, is framed read across " + "the gutter, at about the row's height. Nothing in memory yet", + "store", dict(k_mem=56, smarks={}, touch=False, note_mark=None, reg_frames={"rax": "read"}, pins_after=False)), + ("5", "24 to 48", "the carry", "the carry draws from rax's row down the gutter's right lane to next's word, head " + "first; it is the store's one line (no touch: the row has named the word); as it lands the word is armed", + "store", dict(k_mem=56, smarks={}, touch=False, note_mark=None, reg_frames={"rax": "read"}, + carry=("rax", 0x7fffffffecc8), pins_after=False, arm=0x7fffffffecc8)), + ("6", "60 to 90", "struck, and what follows", "next's word struck (60) and the row's value with it; the carry " + "draws back; then next's pin travels under its node (78 to 108)", + "store", dict(touch=False)), +] + + +def carry_step(g, step, ov): + bx, at, sy = loop_frame(g, step, "tied", None, ov) + if ov.get("arm"): # the destination armed: the arm's frame on its value + a = ov["arm"] + g.frame(976 + 184 + 12 * A + 30 - 5, sy[(a - MOVING[57][3]) // 8], 6 * A + 10, ROW, VERM, 2) + return bx + + +def carry_sheet(out): + ims = [] + y0, y1 = 262, 892 + for i, (num, when, what, why, step, ov) in enumerate(CARRY): + nm = "tmp-carry-%d" % i + save(nm, carry_step, step, ov) + im = Image.open(HERE + "/" + nm + ".png").convert("RGB").crop((0, y0, 1920, y1)) + ImageDraw.Draw(im).rectangle((0, 0, 950, 346 - y0), fill="#0a1030") # the band's foot, cut: left out whole + ims.append((num + " " + when, what, why, im)) + for ext in ("svg", "png"): + subprocess.run(["rm", "-f", "%s/%s.%s" % (HERE, nm, ext)], check=True) + head, lab = 110, 104 + h = y1 - y0 + s = Image.new("RGB", (1920, head + len(ims) * (h + lab)), "#0a1030") + d = ImageDraw.Draw(s) + d.text((64, 26), "carry: a value's way between memory and a register, an arrow", font=FONT("Go-Medium", 34), + fill="#fff8e8") + d.text((64, 70), "with the disassembly tied: a load (prev into rcx), then a store (rax into next), each numbered in " + "its order; frames at 60 a second from the step's first", font=FONT("Go-Regular", 22), fill="#9aa6d9") + f20 = FONT("Go-Regular", 20) + for i, (when, what, why, im) in enumerate(ims): + y = head + i * (h + lab) + d.text((64, y + 8), when, font=FONT("Go-Medium", 26), fill="#e8c46a") + d.text((64 + d.textlength(when, font=FONT("Go-Medium", 26)) + 24, y + 8), what, font=FONT("Go-Medium", 26), + fill="#eee6d2") + lines_, cur = [], "" + for w_ in why.split(): + if d.textlength(cur + " " + w_, font=f20) > 1790 and cur: + lines_.append(cur) + cur = w_ + else: + cur = (cur + " " + w_).strip() + lines_.append(cur) + for j, l_ in enumerate(lines_[:2]): + d.text((64, y + 44 + 26 * j), l_, font=f20, fill="#9aa6d9") + s.paste(im, (0, y + lab)) + s.save(HERE + "/" + out) + + +if __name__ == "__main__": + pair_sheet("44-tied-store.png", "store") + pair_sheet("45-tied-load.png", "load") + strip_sheet("46-tied-call.png", "call reverse: cause, touch, word, then rsp", + "main's call row, the registers, the stack: five instants of the step, numbered in their order " + "(frames at 60 a second from its first); a pin's path drawn a few frames apart", CALL) + strip_sheet("47-tied-prologue.png", "reverse's prologue: the frame set up", + "push rbp in three instants, mov rbp, rsp in one, sub rsp, 0x18 in two, numbered in their order; " + "a pin's path drawn a few frames apart", PROLOGUE) + ways("48-tied-ways.png") + carry_sheet("56-carry.png") |
