1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
#!/usr/bin/env python3
"""The introduction: the frame built from its bytes up, on the recording of targets/list that mocks 9 to 21 use
(list-dbg.txt: the stack from rsp, the heap, the registers; the code's bytes from objdump of the binary). Four
instants of the build, each as the camera frames it.
python3 -B intro.py # 29-intro-bytes, 30-intro-words, 31-intro-stack, 32-intro-code (.svg)
"""
import gen
import dense as D
import context as C
from context import (PAGE, RAISED, RULE, VELLUM, BRIGHT, DIM, FAINT, GOLD, KW, CODE, STACK, DATA, HEAP, READ,
A, S, ROW, TAG, PAD, MONO, BOLD, b, ph, mix, Svg)
RSP = D.RSP
MAPS = [(0x1000000, 0x1001000, "list", "headers, read-only", VELLUM), (0x1001000, 0x1002000, "list", "code", CODE),
(0x1002000, 0x1003000, "list", "read-only data", VELLUM), (0x1003000, 0x1004000, "list", "data", DATA),
(0x1004000, 0x1025000, "heap", "malloc's", HEAP), None,
(0x7ffff7c00000, 0x7ffff7c24000, "libc.so.6", "read-only", VELLUM),
(0x7ffff7c24000, 0x7ffff7d9f000, "libc.so.6", "code", CODE),
(0x7ffff7d9f000, 0x7ffff7e15000, "libc.so.6", "read-only data", VELLUM),
(0x7ffff7e15000, 0x7ffff7e23000, "libc.so.6", "data", DATA), (0x7ffff7fbc000, 0x7ffff7fbe000, "[vdso]", "code", CODE),
(0x7ffff7fbf000, 0x7ffff7fec000, "ld.so", "code", CODE), (0x7ffff7ffb000, 0x7ffff7fff000, "ld.so", "data", DATA),
None, (0x7ffffffde000, 0x7ffffffff000, "[stack]", "the stack", STACK)]
CODE_BYTES = [(0x1001920, "48 89 c1"), (0x1001923, "48 89 f8"), (0x1001926, "48 8b 7f 08"), (0x100192a, "48 89 48 08"),
(0x100192e, "48 85 ff"), (0x1001931, "75 ed")]
def size(n):
for unit, k in (("TiB", 1 << 40), ("GiB", 1 << 30), ("MiB", 1 << 20), ("KiB", 1 << 10)):
if n >= k:
v = n / k
return ("%d %s" if v == int(v) or v >= 10 else "%.1f %s") % (v, unit)
return "%d B" % n
def segments(g, x, y, w, hot=()):
"""`segments`: the process's address space as its mappings, low addresses on top, a row each: a bar in the
region's ink, the first address, what it is, its size; a hole between them one row, how big it is. Rows, not
a scale: the stack and the code are 127 TiB apart. hot: the mappings framed as read (a word just inked)."""
rows = len(MAPS)
y0 = C.panel(g, x, y, w, rows, "the address space", note="the recording's mappings, low on top")
last = None
for i, m in enumerate(MAPS):
yy = y0 + i * ROW
if m is None: # a hole: what is not mapped
nxt = next(mm for mm in MAPS[i + 1:] if mm)
hole = nxt[0] - last
g.path(f"M{x + 14},{yy + 8} l6,4 l-6,4 l6,4", FAINT, 2)
g.t(x + 40, b(yy), "nothing mapped · %s" % size(hole), 18, FAINT, "sans")
continue
lo, hi, name, what, ink = m
g.rect(x + 12, yy + 3, 8, ROW - 6, ink)
C.addr(g, x + 32, yy, lo, ink)
g.t(x + 32 + 13 * A, b(yy), name, S, VELLUM, MONO)
g.t(x + 32 + 13 * A + 11 * A, b(yy), what, 18, DIM, "sans")
g.t(x + w - 12, b(yy), size(hi - lo), S, FAINT, MONO, "end")
if lo in hot:
g.frame(x + 6, yy, w - 12, ROW, READ, 2)
last = hi
return y0
def camera(g, k, cx, cy):
"""The camera at scale k on the point (cx, cy) of the frame: all drawing after this is through it."""
g.o.append(f'<g transform="translate({960 - cx * k},{468 - cy * k}) scale({k})">')
def raw_dump(g, x, y, rows, per=16, words=False, inked=False):
"""The stack's bytes from rsp, `per` to a row; with words, each row's eight bytes read right to left as the
word they make, beside them, in the ink of what it points into when inked. Returns the rows' y."""
ys = []
for r in range(rows):
a0, yy = RSP + per * r, y + r * ROW
ys.append(yy)
C.addr(g, x, yy, a0, STACK if inked else FAINT)
bx = x + 12 * A + 12
vals = [D.MEM.get(a0 + k, 0) for k in range(per)]
for k, v in enumerate(vals):
g.t(bx + k * 30 + (12 if k >= 8 else 0), b(yy), "%02x" % v, S,
mix(VELLUM, PAGE, 0.5) if words else VELLUM, MONO)
if words:
w_ = D.word(a0)
ink = (D.region(w_) or VELLUM) if inked else VELLUM
g.t(bx + per * 30 + 24, b(yy), "%x" % w_ if w_ else "0", S, ink, MONO)
return ys
def frame_bytes(name):
"""The first picture: bytes, nothing else; the camera at x2 on them, where the stack panel will be built."""
gen.W, gen.H = 1920, 1080
g = Svg()
g.o.append('<g transform="translate(300,170) scale(2)">')
g.t(0, -10, "128 bytes, from where rsp points", 18, FAINT, "sans")
raw_dump(g, 0, 0, 8)
g.o.append("</g>")
gen.caption(g, [[("A running program is bytes in memory.",)],
[("These are 128 of them, sixteen to a row.",)]])
g.save(name)
def frame_words(name):
"""Eight bytes a row now, each row's word beside it, inked by where it points; the address space beside."""
gen.W, gen.H = 1920, 1080
g = Svg()
g.o.append('<g transform="translate(64,96) scale(1.35)">')
g.t(0, -10, "eight bytes a row, read right to left, a word", 18, FAINT, "sans")
ys = raw_dump(g, 0, 0, 16, per=8, words=True, inked=True)
k = 1 # 7fffffffece8: the return address, main+80
g.frame(12 * A + 12 - 4, ys[k] - 1, 8 * 30 + 4, ROW + 2, READ, 2)
g.frame(12 * A + 12 + 8 * 30 + 24 - 6, ys[k] - 1, 7 * A + 12, ROW + 2, READ, 2)
segments(g, 12 * A + 12 + 8 * 30 + 24 + 13 * A + 36, -24, 560, hot={0x1001000})
g.o.append("</g>")
gen.caption(g, [[("Eight bytes make a word, stored low byte first: read right to left,",)],
[("this one is ",), ("10018b0", "mono"), (", an address in the code, so it takes code's ink.",)]])
g.save(name)
def frame_stack(name):
gen.W, gen.H = 1920, 1080
g = Svg()
camera(g, 1.25, 976 + 440, 212 + 330)
C.RX = 976
C.registers(g, 212, D.regs(False), D.FLAGS, {})
rows = [r for r in __import__("map").slot_rows(16, 8)]
C.stack(g, 664, rows, __import__("map").frames_from(16, 8), rsp=RSP, roles=__import__("map").roles_from(16, 8))
g.o.append("</g>")
gen.caption(g, [[("The same words as the stack: rsp points at its top, each word",)],
[("has its offset, a frame is a span, and the registers sit over it.",)]])
g.save(name)
BYTES = {0x1001910: "48 85 ff", 0x1001913: "74 20", 0x1001915: "55", 0x1001916: "48 89 e5", 0x1001919: "31 c0",
0x100191b: "0f 1f 44 00 00", 0x1001920: "48 89 c1", 0x1001923: "48 89 f8", 0x1001926: "48 8b 7f 08",
0x100192a: "48 89 48 08", 0x100192e: "48 85 ff", 0x1001931: "75 ed", 0x1001933: "5d", 0x1001934: "c3",
0x1001935: "31 c0", 0x1001937: "c3"}
def aligned(g, y, first, n, cur, cur_line, bytes_=False, title="reverse"):
"""`aligned`: the source and the disassembly side by side, a table in address order: each source line level
with the first row of its run of instructions, a line that comes again (a second run) repeated faint at that
run, a line with no code of its own not drawn (its number missing says so), a row of no line (padding) with
nothing beside it. The pc's row and its line are one band across both columns: the alignment is the thread."""
rows = [r for r in D.disasm_rows() if r[0] >= first][:n]
h = ph(n)
C.tag(g, 64, y, 880, h, "list.c", note="each line beside the first of its instructions")
C.tag(g, 976, y, 880, h, "disassembly", note=title)
y0 = y + TAG + PAD
seen, last_line = set(), None
lead = C.shared([r[0] for r in rows])
i0 = 0 # each run's extent: a quiet bracket by the gutter, line to its last row
for i in range(1, n + 1):
if i == n or rows[i][2] != rows[i0][2]:
if rows[i0][2] is not None:
C.bracket(g, 932, y + TAG + PAD + i0 * ROW + 3, y + TAG + PAD + i * ROW - 3, RULE, 2, 5, side=-1)
i0 = i
for i, (a, func, line, mn, ops) in enumerate(rows):
yy = y0 + i * ROW
on = a == cur
if on: # one band through the gutter: the line and its instruction are one
g.rect(64 + 2, yy, 880 - 4, ROW, C.WASH)
g.rect(944, yy, 32, ROW, C.WASH)
g.rect(976 + 2, yy, 880 - 4, ROW, C.WASH)
g.rect(976 + 2, yy, 24, ROW, GOLD)
g.path(f"M{976 + 20},{yy + 12} l-10,-6 v12 Z", fill=gen.INK)
if line is not None and line != last_line:
again = line in seen
if line == cur_line and on:
g.rect(64 + 2, yy, 50, ROW, GOLD)
g.t(64 + 46, b(yy), str(line), S, gen.INK, BOLD, "end")
else:
g.t(64 + 46, b(yy), str(line), S, FAINT, MONO, "end")
text = D.SRC[line - 1]
C.c_line(g, 64 + 64, yy, text, 66) if not again else g.t(64 + 64, b(yy), text.strip(), S, FAINT, MONO)
seen.add(line)
elif line is None and (i == 0 or rows[i - 1][1] != func):
g.t(64 + 64, b(yy), "%s · no line" % func, 18, FAINT, "sans")
last_line = line
C.addr(g, 976 + 40, yy, a, CODE, lead=lead)
x = 976 + 40 + 8 * A + 12
if bytes_:
g.t(x, b(yy), BYTES.get(a, ""), S, BRIGHT if on else DIM, MONO)
x += 15 * A
g.t(x, b(yy), mn, S, FAINT if mn == "nop" else KW, MONO if mn == "nop" else BOLD)
C.operands(g, x + 7 * A, yy, mn, ops, VELLUM)
if on:
C.chain(g, 976 + 600, yy, [(0x1004098, HEAP), (0x1004070, HEAP)], ("int", 9), {0: "read"} if False else None,
room=976 + 868)
return y0
def frame_code(name):
"""The code chapter: the source and its instructions side by side, each line level with its code, and the
instruction's bytes between the address and the mnemonic: an instruction is bytes too."""
gen.W, gen.H = 1920, 1080
g = Svg()
aligned(g, 48, 0x1001910, 16, 0x1001926, 21, bytes_=True)
gen.caption(g, [[("48 8b 7f 08", "mono"), (" is one instruction: ",), ("mov rdi, [rdi + 8]", "mono"), (", line 21's",)],
[("head->next", "mono"), (". The line sits level with its code: they are one row.",)]])
g.save(name)
def frame_aligned(name):
"""Mock 33: the `aligned` split, reverse and list_done, the pc at the load."""
gen.W, gen.H = 1920, 1080
g = Svg()
aligned(g, 48, 0x1001910, 30, 0x1001926, 21)
gen.caption(g, [[("Line 20, ",), ("while (head)", "mono"), (", has two runs: its test before the body",)],
[("and again after it. Lines 23 to 25 have no code of their own.",)]])
g.save(name)
if __name__ == "__main__":
frame_bytes("29-intro-bytes")
frame_words("30-intro-words")
frame_stack("31-intro-stack")
frame_code("32-intro-code")
frame_aligned("33-aligned")
|