当前位置：首页 > news >正文

安全编程期末复习34（红色重点向下兼容）

news 来源：原创 2025/6/12 21:57:38

三、指针诡计

(1)内存中数据位置

对比栈中数据和数据段中数据的攻击难度

(2)指针介绍

函数指针

对象指针

修改指令指针

对比直接静态调用和函数指针调用的攻击难度

(3)虚函数

编辑

1.回顾 C++ 中的继承、多态

2.引出安全问题 1：虚析构函数（递归调用子类的基类中的析构函数）

3.引出安全问题 2：强制类型转换（向上转型与向下转型）

4.虚指针与虚函数表（虚指针粉碎攻击的基础）

(4)atexit()

.fini_array、atexit() 、exit() 的协作

编辑

exit() 与return的区别

篡改退出函数表攻击与防御

(5)异常处理

向量化、结构化、系统默认异常处理

结构化异常处理SEH

SHE的安全漏洞，攻击与防御（SHE链在栈上的布局、运行时如何入栈、局部变量溢出覆写 handler 指针造成漏洞）

四、动态内存

(1)C内存管理的缺陷

1. 初始化缺陷

2. 未检查返回值

3. 无效指针解引用

4. 释放后访问

5. 双重释放

(2)C++内存管理（重点）

(3)C++内存管理的缺陷

一、内存分配失败检查

二、内存管理函数正确配对

三、多次释放内存

四、释放函数抛异常

(4)内存管理

unlink攻击

一、unlink 攻击的本质

二、如何绕过内存保护？

三、为什么难以检测？

(5)缓解策略

三、指针诡计

(1)内存中数据位置

对比栈中数据和数据段中数据的攻击难度

攻击难度综合对比

对比项	栈数据攻击	数据段数据攻击
防护机制复杂度	高（ASLR、Stack Canary、DEP）	中（内存访问控制、只读保护）
漏洞利用门槛	需精准控制内存地址和数据长度	需找到全局数据的修改入口
代码执行能力	可直接或间接执行代码（ROP）	通常仅篡改数据，需结合其他攻击
现代系统下难度	高（防护机制完善）	中（依赖特定漏洞场景）
典型场景	缓冲区溢出漏洞利用	全局变量越界修改、常量篡改

一般来说，栈中数据的攻击难度相对较高

(2)指针介绍

函数指针

核心定义：函数指针是 指向函数入口地址的指针变量 ，可存储函数地址、动态调用函数，让程序能根据运行时状态决定执行哪个函数，实现 “行为动态化”。

// 定义函数指针类型：指向 “返回 int、参数为 int” 的函数
typedef int (*FuncPtr)(int);  int add(int a) { return a + 5; }  //add函数
int sub(int a) { return a - 5; }  //sub函数int main() {FuncPtr ptr = add;// 函数指针指向 addprintf("%d\n", ptr(3));// 等价于 add(3)，输出 8ptr = sub;// 函数指针切换到指向 subprintf("%d\n", ptr(3));// 等价于 sub(3)，输出 -2 
}

int (*FuncPtr)(int)：

(*FuncPtr)：这里的 * 表明 FuncPtr 是一个指针。

(int)：意味着该指针所指向的函数带有一个 int 类型的参数。

int ...：说明这个函数的返回值类型为 int。

对象指针

核心定义：对象指针是 指向对象（类实例）的指针 ，存储对象在内存中的起始地址，用于访问对象的成员（属性、方法），是面向对象编程（如 C++、Java）中操作对象的基础方式。

class Person {
public:int age;void show() { cout << "Age: " << age << endl; }
};  int main() {// 创建对象指针，指向堆上的 Person 对象Person* p = new Person();  p->age = 20;  // 访问对象成员（属性）p->show();    // 访问对象成员（方法），输出 Age: 20delete p;     // 释放对象return 0;
}

Person* p = ...：

声明了一个名为 p 的指针变量，其类型为 Person*。

把 new Person() 返回的地址赋给指针 p，这样 p 就指向了堆上的 Person 对象。

修改指令指针

本质：指令指针（比如 x86 架构里的 EIP/RIP 寄存器）存储的是 CPU 下一条要执行指令的内存地址。“修改指令指针” 就是通过代码（比如汇编指令、特殊的跳转 / 调用逻辑）去改变这个地址，让程序流程跳转到其他位置执行。

对比直接静态调用和函数指针调用的攻击难度

对比维度	直接静态调用（如 `func()`）	函数指针调用（如 `ptr()`）
执行流确定性	编译时固定地址，执行流清晰可控	运行时动态决定目标地址，执行流灵活
攻击篡改点	需直接修改代码段（难度极高，代码段通常只读）	篡改函数指针变量（栈 / 堆内存，相对容易）
防护机制影响	ASLR 对静态地址保护弱（代码段地址可预测）	ASLR 直接打乱指针指向，需额外信息泄露配合
典型攻击路径	需突破代码段只读保护（如内核漏洞提权）	栈溢出 / 堆溢出篡改指针值，指向恶意代码
攻击难度总结	极高（修改只读内存 + 执行流固定）	中等（篡改动态指针 + 依赖内存漏

直接静态调用攻击难度更高，因其编译时绑定函数地址，调用关系固定，需突破 ASLR、DEP 等系统防护及编译器保护（如 Canary）才能篡改；而函数指针调用为动态绑定，攻击者可通过修改指针指向的内存地址（如栈、数据段中的指针值）重定向调用目标，无需绕过代码段随机化保护，攻击难度相对较低。

(3)虚函数

1.回顾 C++ 中的继承、多态

继承：子类（派生类）可以继承父类（基类）的成员变量、成员函数，实现代码复用。比如 class Dog : public Animal ，Dog 能继承 Animal 的 eat()、sleep() 等函数。

多态：核心靠虚函数实现，分为 静态多态（函数重载） 和 动态多态（运行时多态） 。动态多态的关键是：基类定义虚函数（加 virtual 关键字），子类重写（override ） 该函数；程序运行时，通过基类指针 / 引用指向子类对象，调用虚函数时会动态绑定（根据对象实际类型，调用对应的子类实现）。

//示例：
class Animal {
public:virtual void speak() { cout << "Animal speaks" << endl; }
};//Dog 类通过 public 继承 Animal 类，获得了 Animal 中 speak 虚函数等成员（继承父类属性、方法的能力 ）
class Dog : public Animal {
public:void speak() override { cout << "Dog barks" << endl; } 
};int main() {Animal *animal = new Dog(); animal->speak(); // 输出 Dog barks，动态多态体现delete animal;return 0;
}

继承：Dog 继承 Animal 类，复用父类结构并可扩展；

多态：父类 Animal 声明虚函数 speak，子类 Dog 重写后，通过父类指针 animal 指向子类对象 Dog，运行时自动调用 Dog 的 speak，实现 “同一调用、不同行为” 的动态多态效果。

2.引出安全问题 1：虚析构函数（递归调用子类的基类中的析构函数）

问题根源：如果基类析构函数不是虚函数，用基类指针 delete 子类对象时，可能只调用基类析构，不调用子类析构 → 子类里动态分配的资源（如堆内存）无法释放，导致内存泄漏。

解决方法：基类把析构函数声明为 virtual（虚析构函数）。这样，delete 基类指针指向的子类对象时，会从子类析构开始，自动向上（基类）递归调用析构 ，保证子类、基类资源都释放。

// 错误示例：基类无虚析构
class Base {
public:~Base() { cout << "Base destructor" << endl; } 
};
class Derived : public Base {int *data;
public:Derived() : data(new int(10)) {}~Derived() { delete data; cout << "Derived destructor" << endl; }
};
// main 中：
Base *obj = new Derived();
delete obj; 
// 输出：Base destructor → 子类Derived 的析构没被调用 → data 内存泄漏// 正确示例：基类加虚析构virtual
class Base {
public:virtual ~Base() { cout << "Base destructor" << endl; } 
};
// delete obj 时，先调用子类Derived 析构（释放 data ），再调用父类Base 析构 → 无泄漏

虚析构函数（总结）：
加 virtual 确保删除子类对象时，先调用子类析构、再调用父类析构
防止因父类指针指向子类对象，析构时漏掉子类资源释放（内存泄漏）