写一个最简单的程序,只打印一个局部变量的地址,连续跑三次,你大概率会看到三个不同的值:0x7ffd3c2a1b4c、0x7ffd1e8f2a1c、0x7fffe9a3ab4c。变量还是那个变量,程序还是那个程序,地址却在变。更奇怪的是,同一个进程里,函数地址可能是 0x55... 开头,库函数地址是 0x7f... 开头,栈上的变量又是 0x7ff... 开头,三个数字差得离谱。
这不是编译器在乱排。现代操作系统给每个进程发了一整套「假地址」,程序里看到的每个指针都是虚拟地址,真正落到哪块物理内存由内核和页表负责。弄懂这套地址空间的划分,是后面所有栈溢出、堆利用、地址泄露的基础。地址在哪个段、那个段能不能写、能不能执行,直接决定了某次越界写会造成什么后果。
/proc/pid/maps、gdb 里的内存视图只对你自己启动的进程有意义;未经授权读取或调试他人系统上的进程,属于越界行为,可能承担法律责任。你看到的地址不是物理地址
程序里打印出来的 0x7ffd...,是虚拟地址。CPU 访问内存时,先经过 MMU 查页表,把虚拟地址翻译成物理地址,再真正读写。每个进程都有自己独立的页表,所以两个进程同时把同一个虚拟地址映射到不同的物理页,互相看不见对方的数据。这也是进程隔离的地基。
x86-64 的页大小通常是 4KB,一个虚拟地址被拆成页号加页内偏移。用户态能用的地址范围不是完整的 64 位,而是低 47 位左右,最高一段留给内核。你在程序里看到的高地址 0x7fff... 已经接近用户空间的顶部,再往上就是内核空间,用户态直接访问会被拒绝。
用 size 命令可以先把一个二进制「静态」的部分量出来:
size ./demo
text data bss dec hex filename
1234 512 64 1810 712 ./demo
这里的 text 是代码和只读常量,data 是初始化过的全局/静态变量,bss 是没初始化或初始化为零的全局/静态变量。它们只是文件里的段大小,运行时还会被映射到不同的虚拟地址上。要看到完整的运行时布局,得看进程自己的 maps 文件。
一张从低到高的地址地图
把一个 64 位 Linux 进程的地址空间按从低到高排一下,大致是下面这几层。不同发行版、不同编译选项会有细节差异,但大骨架是稳定的。
注意两个方向:栈往下长,堆往上长。它们中间还隔着共享库和 mmap 区,所以并不会真的「撞上」。很多人以为栈和堆挨着,其实只有在很老的布局或者特殊参数下才接近,现代进程里两者通常隔着几个数量级。
再看具体数值。没开 PIE 的程序,代码段通常固定在 0x400000 附近;开了 PIE,代码段基址会落在 0x55... 这样的随机位置。libc 这类共享库通常在 0x7f...,栈在 0x7ffc... 到 0x7fff... 之间。为什么差这么远?因为每一块区域在地址空间里有自己的保留区间,内核加载时只需要在对应区间里挑一个随机基址,不需要把它们挤在一起。
用 /proc/self/maps 能看到当前进程的真实分区。一个典型输出如下(地址做了省略,格式保持原样):
55d4a1c00000-55d4a1c01000 r--p 00000000 /home/user/demo
55d4a1c01000-55d4a1c02000 r-xp 00001000 /home/user/demo
55d4a1c02000-55d4a1c03000 r--p 00002000 /home/user/demo
55d4a1c03000-55d4a1c04000 rw-p 00003000 /home/user/demo
55d4a3b2f000-55d4a3b50000 rw-p 00000000 [heap]
7f2c8e400000-7f2c8e5c0000 r-xp 00000000 /usr/lib/x86_64-linux-gnu/libc.so.6
7ffd3c2a1000-7ffd3c2c2000 rw-p 00000000 [stack]
每一行是「起始地址-结束地址 权限 文件偏移 路径」。权限那四位分别是读、写、执行、私有/共享。你能直接看出来:同一个可执行文件被拆成四段映射,代码段是 r-xp(可读可执行不可写),数据段是 rw-p(可读写不可执行),栈也是 rw-p。这个「栈不可执行」就是 NX 保护的直接表现,第四篇会详细讲。
栈帧:一次函数调用留下什么
栈是整篇文章里最需要记牢的部分,因为最经典的溢出就发生在栈上。先看一次函数调用在 x86-64 上做了什么。
调用方先把参数放进寄存器:前六个整数或指针参数依次放 rdi、rsi、rdx、rcx、r8、r9,更多参数才压栈。然后执行 call 指令,CPU 会自动把下一条指令的地址压栈,这个值就是返回地址。被调用的函数接着执行自己的序言:
push rbp ; 保存调用者的栈帧指针
mov rbp, rsp ; 建立当前函数的栈帧
sub rsp, 0x20 ; 给局部变量留空间
...
leave ; 等价于 mov rsp, rbp; pop rbp
ret ; 弹出返回地址,跳回去
执行完序言后,rbp 指向当前栈帧的底部,局部变量放在 rbp-0x10、rbp-0x20 这些负偏移处;[rbp] 存着调用者的 rbp,[rbp+8] 就是返回地址。栈向低地址增长,所以「越界往高地址写」正好会先碰到保存的 rbp,再碰到返回地址。第三篇会沿着这条线把溢出过程拆开。
编译出来的实际偏移不一定和源码里的数组大小一致。一个 char buf[16] 可能被放在 rbp-0x10,也可能因为对齐被放在 rbp-0x20,中间还可能有 canary。永远不要用「数组多大,偏移就是多大」来推算,必须在反汇编里看 lea 或 mov 用的偏移。
另外,x86-64 要求调用函数时 rsp 保持 16 字节对齐(call 之前)。这个细节平时不重要,但在构造返回地址链时会让程序在 libc 里的某条 movaps 指令上崩掉,第五篇会专门说这个坑。
堆和栈不是一回事
栈上的内存由编译器分配,函数返回就自动回收;堆上的内存由程序自己申请,用 malloc 拿到、用 free 还回去。两者在地址空间里位置不同,管理方式也完全不同。
栈
由 rsp 和 rbp 划定范围,函数进出自动伸缩。分配和释放只是移动寄存器,速度极快。大小受线程栈限制,默认通常 8MB。生命周期严格跟随函数调用,返回后就失效。
堆
由 malloc 实现管理,按需向内核申请页。小分配走 brk 扩展,大分配(常见阈值 128KB)直接 mmap。释放后内存不一定还给内核,可能留在空闲链表里等下次复用,所以「free 了」不等于「地址立刻不可访问」。
这个差别解释了一个常见困惑:为什么 free 之后程序还能读写那块内存,甚至还能打印出旧内容?因为 free 只是把这块内存标记为可用,地址仍然映射着,内容也没被清掉。这类「释放后继续用」(use-after-free)是堆上最常见的安全问题之一,第六篇会展开。
堆的地址通常紧跟在数据段后面,用 brk 向上扩展;当需要的空间很大时,glibc 会改用 mmap 在共享库附近另开一块。所以你有时会看到两个 malloc 出来的地址离得很远,这不是 bug,是分配器换了策略。
权限位决定「能做什么」
地址空间不是一个平面的内存块,而是一组带权限的映射。读、写、执行三种权限的组合,直接决定了某次越界写之后能走多远。
代码段通常是 r-x:能读能执行,不能写。数据段和栈是 rw-:能读能写,不能执行。只读数据段是 r--:只能读。内核在页表里给每一页记着这些位,CPU 访问时如果违反,就触发页错误;如果错误无法修复,进程收到 SIGSEGV。
很多人第一次听说「栈不可执行」会觉得奇怪:栈上明明存着数据,为什么不能当代码跑?这正是 NX(No eXecute)保护的目的。早期攻击者把一段机器码写进栈上的缓冲区,再把返回地址指过去,就能执行自己的代码。把栈标成不可执行之后,这条路径被堵死,攻击者只能转向「复用已有代码」的思路,也就是第五篇的 ROP。
用 readelf -l 可以看到段的权限标志。注意 GNU_STACK 那一行:
readelf -l ./demo | grep -A1 GNU_STACK
GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000
0x000000 0x0000000000000000 RWE
如果你看到 RWE,说明栈同时可读可写可执行,NX 没开;正常的现代二进制这里是 RW。这个区别在第四篇会配合 checksec 一起讲。
本机实测的两组地址如下,-no-pie 与默认 PIE 各编一份:
# gcc -O0 -g -fno-stack-protector -no-pie layout.c -o layout
func = 0x401146 g_init = 0x404020 g_bss = 0x404034
s_static = 0x404024 msg(ptr) = 0x404028 literal = 0x402004
local = 0x7ffd4a7062d4 malloc = 0xd3d22a0
printf = 0x7f6d0cafc5b0
# 默认 PIE,连跑两次
func = 0x559b5d703149 local = 0x7fffaa7273c4 malloc = 0x559b980142a0
func = 0x55c3c49f4149 local = 0x7fffff2821e4 malloc = 0x55c3e7ee12a0
对照 readelf -S:.text 在 0x401060、.rodata 在 0x402000、.data 在 0x404010、.bss 在 0x404030。非 PIE 下函数和全局变量都落在 0x400000 附近;PIE 版本两次运行的高位差了好几万亿,因为整个映像被随机搬走了。堆在非 PIE 下是 0xd3d22a0 这种从数据段末尾用 brk 扩出来的地址,PIE 下则跟在映像末尾(0x559b...42a0);栈无论哪种都在 0x7ff...。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 同一个局部变量,三次运行打印出三个地址 | ASLR 随机化了栈的起始基址 | cat /proc/sys/kernel/randomize_va_space,再用 setarch -R 对比 |
函数地址是 0x55...,栈地址是 0x7ffc... | PIE 程序被加载到随机基址,栈在用户空间顶部,两者本来就在不同区间 | readelf -h 看 Type,checksec 看 PIE |
关掉 PIE 后,函数地址固定落在 0x400000 附近 | 非 PIE 是 ET_EXEC,加载地址写死在 ELF 头里 | file ./demo、readelf -h ./demo |
| 堆地址紧跟在数据段后面,且每次只差一点点 | 小分配走 brk,堆从数据段末尾向上扩展 | /proc/pid/maps 里的 [heap] 行,gdb 里 vmmap |
| 读一个字符串常量时崩溃,提示只读 | 字符串放在 .rodata,页权限是 r-- | readelf -S 找 .rodata,gdb 里 x/s 看地址 |
| gdb 里地址固定,直接在 shell 里跑却每次不同 | gdb 默认关闭地址随机化,方便调试 | show disable-randomization,退出 gdb 后再跑 |
这张表里的每一条都能在十分钟内验证。排查地址问题时,先问「这是哪个段」,再问「这个段的权限是什么」,最后才问「这个地址是谁写的」。顺序对了,现象就不会看起来那么神秘。
边界与代价
边界还是那句话:所有观察都限定在自己的进程和靶场。地址布局知识本身不构成攻击能力,但它能让你看懂别人的二进制在做什么;把这种能力用在未授权目标上,性质就变了。尤其不要用「我只是看看 maps」当理由,未授权探测他人系统同样可能违法。
代价有三个。第一,布局不是永远不变:内核版本、发行版、编译选项、线程栈大小都会影响具体地址,照抄某篇教程里的 0x7ffc... 没有意义。第二,虚拟地址到物理地址的映射对用户态不可见,不要试图从 /proc/self/maps 推断物理内存布局,那是一条错路。第三,gdb 和直接运行的环境不同,gdb 会关掉 ASLR、可能改变环境变量和栈布局,调试时看到的偏移和真实运行时可能差几个字节。凡是涉及精确偏移,必须在目标同款环境里复测。
还有一个容易被忽略的点:地址空间布局是安全机制的一部分。PIE 和 ASLR 的目的就是让攻击者不知道关键对象在哪;理解布局是为了理解这层防御,而不是为了绕过它。真正做防御时,你会用同样的知识去检查自己的程序有没有把敏感数据放在可写段、有没有让长度变量和缓冲区相邻。
真实踩坑与判断方法
第一个坑是把「文件里的段」当成「运行时的映射」。size ./demo 给出的 text 是文件里代码段的大小,而 /proc/pid/maps 里的 r-xp 区间是按 4KB 页对齐后的结果,还会把权限相同的相邻段合并。所以两边数字对不上是正常的:maps 的区间长度基本是 4096 的整数倍,起始地址末三位是 000。如果你看到的区间不按页对齐,多半是看错了对象。
第二个坑是 cat /proc/$$/maps 里的 $$。它在 bash 里是当前 shell 的 PID,不是你要观察的程序。判断很简单:第一行映射的可执行文件路径如果是 /usr/bin/bash,你看到的是 shell 自己的地址空间。正确做法是让程序自己读 /proc/self/maps,或者先 pgrep -f ./demo 拿到 PID 再 cat /proc/<pid>/maps。
第三个坑和随机化有关。判断 ASLR 开没开,不要看「地址像不像随机的」,直接看两个值:cat /proc/sys/kernel/randomize_va_space 返回 2 表示全开,0 表示关闭,1 表示只随机化共享库;再连续运行五次打印栈地址的程序,如果五次完全相同,说明随机化没生效——要么系统里被关了,要么你其实是在 gdb 里跑。这一点我在本机 Linux 上验证过:cat /proc/sys/kernel/randomize_va_space 返回 2,同一个程序连跑五次,局部变量地址依次是 0x7ffe648a8bf4、0x7ffde9a690f4、0x7ffda6418874、0x7ffe58c679c4、0x7ffead267114;换成 setarch $(uname -m) -R 再跑五次,五次都是 0x7fffffffeb34。gdb 里因为默认 disable-randomization on,地址同样稳定,Windows PE 上的对照也是如此。所以「地址不变」不能单独证明 ASLR 被关:Linux 上必须看 randomize_va_space,返回 2 说明全开,此时地址不变只可能是你正跑在 gdb 里或用了 setarch -R。判断顺序永远是先看系统开关,再看调试器设置,最后才怀疑程序。
对应的防御点在真实项目里是这样的:敏感数据(密钥、令牌、用户缓冲区)不要和长度字段、函数指针放在同一块可写内存里,避免一次越界写同时改掉两者;发布构建开 PIE 与 Full RELRO,让代码和 GOT 的位置不可预测且只读;日志和错误上报里不要打印完整指针值,那是最廉价的信息泄露;崩溃采样如果上传第三方平台,先确认里面没有内存内容和路径。
靶场里能验证的练习
- 写一个
layout.c,分别打印函数地址、全局变量地址、静态变量地址、局部变量地址、malloc返回的地址、字符串常量的地址、printf的地址。用-no-pie和默认 PIE 各编译一次,把两组地址按从低到高排序,标注每一段属于哪个区域。 - 在程序里打开
/proc/self/maps并打印前二十行;或者直接在 shell 里执行cat /proc/$$/maps。找出[stack]、[heap]和 libc 的区间,确认它们的权限位。 - 对同一个二进制执行
size ./demo、readelf -S ./demo、readelf -l ./demo,把.text、.rodata、.data、.bss的大小和权限抄下来,再和运行时 maps 对照。 - 用 gdb 在某个函数入口下断点,执行
info frame、p &buf、x/8gx $rsp,找到保存的rbp和返回地址,算出从缓冲区开头到返回地址差多少字节。 - 连续运行五次打印栈地址的程序,再用
setarch $(uname -m) -R ./demo运行五次,比较两组结果,解释为什么第二组稳定。
/proc/self/maps、分区地址、权限位和 ASLR 对照都在 Debian 12 虚拟机(gcc 12.2.0、gdb 13.1、glibc 2.36)上实测;randomize_va_space 为 2。info proc mappings 的节选里代码段是 r-xp、数据段是 rw-p、libc 分四段映射、ld.so 与 [vdso] 都在高位。Windows PE 侧只做了对照,不用于推断 Linux 布局。小结
三句话收一下:进程看到的是虚拟地址,地址空间按代码、只读数据、数据、堆、共享库、栈从低到高分布;栈帧里最关键的是 [rbp] 的旧栈帧指针和 [rbp+8] 的返回地址;每个段都有读写执行权限,栈不可执行正是 NX,也是后面要面对的第一道防护。
下一篇就沿着栈帧往下走:当一个长度不受控的写入发生在局部数组上,它到底会按什么顺序覆盖哪些东西?为什么有时候 17 个字节就崩,有时候写了两百个字节才崩?把「偏移」这个概念算清楚,你才有资格谈「控制返回地址」。还没有 Linux 环境的,先看第七篇的环境一节。