软件安全漏洞分析与发现复习笔记

1 绪论

本节无考点，仅供了解。

2 基础知识

考点： 汇编码理解和撰写，三种内存地址，不同的页管理方式。windows保护模式可能出题

汇编算法的阅读理解
给出汇编片段，理解其意思，输入->输出
保护模式的内存寻址，现代OS的分页机制
x86机器码转换到汇编代码
windows内存管理分页模式推导，系统调用
ELF动态代码链接延迟绑定（逆向中综合），linux下的系统调用

2.1 处理器硬件架构基础

CPU按照字长可分为16位、32位和64位。

汇编指令细节这里不展开了。下面是考试要求：

这里给个示例代码：

section .data
    array dd 1, 2, 3, 4, 5  ; 定义一个数组，包含5个元素
    array_len equ 5         ; 定义数组长度

section .text
    global _start

_start:
    xor eax, eax            ; 将 eax 清零，用于存储累加和
    xor ecx, ecx            ; 将 ecx 清零，用于索引数组元素

sum_loop:
    cmp ecx, array_len      ; 比较索引是否达到数组长度
    jge end_loop            ; 如果索引 >= 数组长度，跳转到 end_loop

    add eax, [array + ecx*4] ; 将当前数组元素的值加到 eax
    inc ecx                 ; 索引加1
    jmp sum_loop            ; 跳回到 sum_loop 开始

end_loop:
    ; 这里可以添加其他代码，eax 中已经包含数组元素的累加和

    ; 退出程序
    mov eax, 1
    int 0x80

保护模式

实模式没有内存保护机制，任何程序都可以访问系统内的任意内存地址。这导致一个程序可能会覆盖另一个程序的内存，从而导致系统崩溃。
保护模式内存寻址
逻辑地址转线性地址

线性地址转物理地址

1.给定一个逻辑（虚拟）地址，尝试找到它的物理地址
在现代操作系统中，虚拟地址通过分页机制映射到物理地址。这个过程涉及页目录和页表。以下是一个示例过程：

虚拟地址结构（假设 32 位系统）：

虚拟地址：0x12345678
页目录索引：虚拟地址的高 10 位（0x12345678 >> 22）
页表索引：虚拟地址的中间 10 位（(0x12345678 >> 12) & 0x3FF）
页内偏移：虚拟地址的低 12 位（0x12345678 & 0xFFF）
查找过程：

使用页目录索引查找页目录，找到页表地址。
使用页表索引查找页表，找到物理页框地址。
物理地址 = 物理页框地址 + 页内偏移。

2.使用程序指令无法访问物理地址，那么操作系统是如何修改页目录表和页表
操作系统运行在高特权级别（内核模式），可以直接访问和修改页目录和页表。以下是一个示例过程：

特权级

2.2 反汇编与反编译基础

略。

2.3 Windows 操作系统基础

2.4 Linux 操作系统基础

略。

3 基础分析工具介绍

略。查ppt。

4 程序切片（重点）

考点：程序切片：集中出题。
1、控制流、数据流（可达性（参考ppt中的案例）、活跃变量）和程序依赖图（包括数据依赖和控制依赖）
2、现有的切片方法的应用：基于图可达性的静态切片计算
3、不考察数据流方程
4、最好提前看一下动态切片（方法二）的例子

程序切片
- 数据流和控制流（和污点分析结合），控制流图（如何画）和程序依赖图的区别
- 可到达定义（算法，示例）、活性分析（理解概念）
- 静态切片
  - 数据流方程（不考察，了解即可）
  - 图可达算法
- 动态切片（往年静态切片为主，说不定会有动态）
  - 基于程序依赖的切片（几种优化方法，和可到达定义的结合）
  - 方法三后不用看

控制流分析

在这里插入图片描述

数据流分析

可到达定义分析（考察计算题）

修正：上图中的语句2 的可到达语句不包括4。

定义集合
我们先确定每个语句的 Gen 和 Kill 集合：

Gen(0) = {0}
Kill(0) = {}
Gen(1) = {1}
Kill(1) = {}
Gen(2) = {2}
Kill(2) = {}
Gen(4) = {4}
Kill(4) = {1}
Gen(5) = {5}
Kill(5) = {0}
Gen(7) = {7}
Kill(7) = {1, 4}
Gen(8) = {8}
Kill(8) = {0, 5}
Gen(9) = {9}
Kill(9) = {2}
路径分析
接下来我们分析从入口到 [9] 的所有路径：

[0] -> [1] -> [2] -> [3] -> [4] -> [5] -> [9]
[0] -> [1] -> [2] -> [3] -> [6] -> [7] -> [8] -> [9]
在每个路径上，我们计算每个语句的 In 和 Out 集合。

路径1: [0] -> [1] -> [2] -> [3] -> [4] -> [5] -> [9]
In(0) = {}
Out(0) = Gen(0) = {0}
In(1) = Out(0) = {0}
Out(1) = Gen(1) ∪ (In(1) - Kill(1)) = {1} ∪ {0} = {0, 1}
In(2) = Out(1) = {0, 1}
Out(2) = Gen(2) ∪ (In(2) - Kill(2)) = {2} ∪ {0, 1} = {0, 1, 2}
In(3) = Out(2) = {0, 1, 2}
Out(3) = In(3) = {0, 1, 2}
In(4) = Out(3) = {0, 1, 2}
Out(4) = Gen(4) ∪ (In(4) - Kill(4)) = {4} ∪ {0, 2} = {0, 2, 4}
In(5) = Out(4) = {0, 2, 4}
Out(5) = Gen(5) ∪ (In(5) - Kill(5)) = {5} ∪ {2, 4} = {2, 4, 5}
In(9) = Out(5) = {2, 4, 5}

路径2: [0] -> [1] -> [2] -> [3] -> [6] -> [7] -> [8] -> [9]
In(0) = {}
Out(0) = Gen(0) = {0}
In(1) = Out(0) = {0}
Out(1) = Gen(1) ∪ (In(1) - Kill(1)) = {1} ∪ {0} = {0, 1}
In(2) = Out(1) = {0, 1}
Out(2) = Gen(2) ∪ (In(2) - Kill(2)) = {2} ∪ {0, 1} = {0, 1, 2}
In(3) = Out(2) = {0, 1, 2}
Out(3) = In(3) = {0, 1, 2}
In(6) = Out(3) = {0, 1, 2}
Out(6) = In(6) = {0, 1, 2}
In(7) = Out(6) = {0, 1, 2}
Out(7) = Gen(7) ∪ (In(7) - Kill(7)) = {7} ∪ {0, 2} = {0, 2, 7}
In(8) = Out(7) = {0, 2, 7}
Out(8) = Gen(8) ∪ (In(8) - Kill(8)) = {8} ∪ {7} = {7, 8}
In(9) = Out(8) = {7, 8}

对于路径1和路径2，我们得出In(9) = {2, 4, 5} ∪ {7, 8} = {2, 4, 5, 7, 8}
综合所有路径 Out(9) = Gen(9) ∪ (In(9) - Kill(9)) = {4, 5, 7, 8, 9}
[9] 处的可到达定义是 {4, 5, 7, 8, 9}。

Soundness（正确性）：在数据流分析中，一个分析方法是“sound”的，意味着它不会遗漏任何可能影响程序行为的重要信息。在可到达定义分析中，soundness 意味着所有实际可能到达某点的定义都应该被包含在结果中。
False Positives（误报）：在可到达定义分析中，误报指的是分析认为某个定义可达，但实际上在程序执行时不可能达到。一般来说，为了保持正确性，分析方法通常会倾向于保守，即宁愿包含更多的定义（可能的误报），也不遗漏任何实际可达的定义。
该方法是 sound 的，不会遗漏任何可能的定义。由于保守的性质，可能会存在误报，但这是为了确保正确性而做出的权衡。