静态程序分析大作业设计过程

前言

初步了解了静态代码分析器的概念以及如何实现
目前只打算实现 c和python两种语言的代码分析
前者用pycparser库 后者用ast库 后面如果找到更好的方案再进行替换

C

ast树分析

打算先从c语言的代码分析开始做 毕竟比较熟悉c的代码安全隐患
pycparser库默认是不支持预处理语句的 比如#define和#include
要么是自己删除或者就是使用fake_libc_include来提前处理好
个人更偏向于前一种办法吧 后者输出的节点实在太多了 感觉会影响到处理效率(主要还是一开始不熟悉 看的头都大了 后面再看看怎么优化)

import ast
from pycparser import c_parser, parse_file

ast = parse_file("test.c", use_cpp = True, cpp_path=r'D:\环境\c\mingw64\bin\gcc.exe', cpp_args=['-E', r'-Ifake_libc_include'])

print(ast)

import ast
from pycparser import c_parser, parse_file

ast = parse_file("test.c")

print(ast)

按照上述代码输出一个简单c语言代码的ast语法树

int main(){
    printf("%s","hello\n");
    return 0;
}

输出结果如下图

FileAST是根目录类型 其包括3种 也只有3种下级节点
Decl: 变量声明节点
FuncDef: 函数声明节点
TypeDef: typedef数据类型定义
以上述的语法树为例 其只包括FuncDef节点

FuncDef一共有3个属性
self.decl 表示一个标识符的声明 包含FuncDecl的decl节点
self.coord 标识符字符串所在行列
self.body 函数实现的代码块

先从decl节点开始看
其又包括7个下级节点

quals表示函数是否有特定的修饰符 例如const int main()就是有特定修饰符const
align表示函数是否有对齐要求
storage表示函数是否有存储类修饰符 例如static
funcspec表示函数是否有函数规格修饰符 例如内联汇编inline
init表示函数是否有初始值 通常用于变量声明 函数声明中为0
bitsize表示变量在声明时是否有限制位数

FuncDecl有两个属性
args和type
args表示该函数的定义是否有参数
type表示该函数的返回类型

type中又分为declname quals align type四个下级节点
其他节点已经介绍过了 declname就是函数的名称

接着往下看 param_decls负责记录函数所需要的参数 比如int main(int a) 就会记录a下来

接着来看body部分
block_items是一个列表 包含代码块中的所有语句 这里就是printf和return两个
FuncCall有两个下级节点 name记录调用的函数名 args记录函数调用到的参数

根据上面所学到的 如果这里想要检测代码是否调用了危险函数 就是检查body->FuncCall->name 查出来后还可以通过coord属性输出危险函数位于第几行

import ast
from pycparser import c_parser, parse_file
from pycparser.c_ast import *

ast = parse_file("test.c",use_cpp=False)

for i in ast.ext[0].body.block_items:
    if isinstance(i,FuncCall):
        if i.name.name == "gets":
            print(f"代码中调用了危险函数gets 行号：{i.coord.line}")

安全规则设置

捋清楚了ast树的结构后 接下来的难点就是在于如何设置分析规则 感觉头都大了
比如下面这一小段代码 首先要检测出来使用了危险函数 然后还要检测出来数组buf只定义了0x20字节 而read函数往buf数组里写了0x30字节 然后还得检测printf涉及到的参数只有一个 随后去检测这个参数是否为用户可控的 从而判断是否存在格式化字符漏洞
我觉得最大的难点在于怎么判断参数是否为用户可控的 这就意味着需要遍历block_items的所有成员 去逐个判断当前函数是否为输入函数or可往数组中写入数据的函数 少一个都得漏报…. 不过简单粗暴一点就是检测出来printf就一个参数直接一棒打死就行了(不过万一写代码的只是写了一个printf(“hello”)呢)
所以这就需要在开始写安全规则之前就拟定好一个对ast树审计的算法 要求做到可调整性和高效率性 不然就会演变成写安全协议大作业的时候 后期写成了屎山代码

int main(){
    char buf[0x20];
    gets(buf);
    read(0,buf,0x30);
    printf(buf);
}

初步规划为以下步骤
1.先分析代码中定义的函数
2.统计函数中定义的变量or作为函数参数的变量
3.分析函数中调用到的函数是否存在安全漏洞

上述的步骤中存在一个致命的问题

#include<stdio.h>
#define aaa 10

void print_buf(char buf[]){
    printf(buf);
}

void test(){
    puts("hello");
}

int main(){
    char buf[0x20];
    gets(buf);
    read(0,buf,0x30);
    print_buf(buf);
}

如果待分析代码是上述的代码 print_buf函数中的buf参数 要怎么跟进到是main里面定义的呢 感觉这里需要一个优秀的算法来决定函数的分析顺序
按照我的想法 是先遍历所有函数 找到main函数 从main函数开始分析 遇到调用的函数就跟进分析

v0.1

暂时写了一个初版代码 发现存在的问题还是很多的
首先就是判断提供的测试文件使用了哪种编程语言 这里用的是magic库来判断
随后去除c语言文件中的#include和#define
接着就是安全规则的部分了 写的逻辑不是很好

import ast
from pycparser import c_parser, parse_file
from pycparser.c_ast import *
import magic

file_name = "test.c"
buf_array = []

def init():
    with open("temp.c","r") as file:
        data = file.read()
        if data != 0:
            with open("temp.c","w") as file2:
                file2.write("")

def check_filetype():
    file_type = magic.from_file(file_name)
    if "C" in file_type:
        print("源码为c语言")
        return 1
    elif "Python" in file_type:
        print("源码为python语言")
        return 2

def c_deal():
    with open(file_name,"r") as file:
        for line in file:
            if not line.startswith("#include") and not line.startswith("#define"):
                with open("temp.c","a") as file2:
                    file2.write(line)

def python_deal():
    print("......")

def c_ast(array_size):
    ast = parse_file("temp.c",use_cpp = False)
    print(ast)
    for i in ast.ext:
        if i.decl.name == "main":
            for j in i.body.block_items:
                if isinstance(j,Decl):
                    buf_array.append(j.name)
                    array_size += int(j.type.dim.value,0x10)
                if isinstance(j,FuncCall):
                    if j.name.name == "gets":
                        print(f"代码调用了危险函数 行号:{j.coord.line}")
                    if j.name.name == "strcpy":
                        print(f"代码调用了危险函数 行号:f{j.coord.line}")
                    if j.name.name == "read":
                        if int(j.args.exprs[2].value,0x10) >= array_size+16:  #64位
                            print(f"代码可能存在栈溢出漏洞 行号:{j.coord.line}")


def main():
    init()
    array_size = 0
    file_type = check_filetype()
    if file_type == 1:
        c_deal()
        c_ast(array_size)
    elif file_type == 2:
        python_deal()
if __name__ == "__main__":
    main()

如果函数中定义了两个数组 char a[0x20] char b[0x30]
往b中输入0x40 read(0,b,0x40)
按照代码中的判断逻辑 0x40<0x50 所以不会报栈溢出错误 但是实际上数组b溢出的长度为0x30 所以应该还要处理好数组在栈帧中的位置

v0.2

这一版代码 主要优化了检测的逻辑 针对栈溢出的漏洞检测更加细致 同时敲定了后续的安全规则主体逻辑 即从main函数出发 根据main函数中涉及到的自定义函数来逐个分析 同时区分了是否采用main函数中定义的参数 不过在很多地方还是存在没有预料到的特殊情况处理 还需要继续打磨
目前已知缺陷: 缺少对于变量的处理 如果read函数的第三个参数是变量 当前代码就无法判断具体的数值大小
各个漏洞的函数判定范围太小 存在其他情况

import ast
from pycparser import c_parser, parse_file
from pycparser.c_ast import *
import magic

file_name = "test.c"
buf_array = []

def init():
    with open("temp.c","r") as file:
        data = file.read()
        if data != 0:
            with open("temp.c","w") as file2:
                file2.write("")

def check_filetype():
    file_type = magic.from_file(file_name)
    if "C" in file_type:
        print("源码为c语言")
        return 1
    elif "Python" in file_type:
        print("源码为python语言")
        return 2

def c_deal():
    with open(file_name,"r") as file:
        for line in file:
            if not line.startswith("#include") and not line.startswith("#define"):
                with open("temp.c","a") as file2:
                    file2.write(line)

def python_deal():
    print("......")

def danger_function_check(i):
    if isinstance(i,FuncCall):
        if i.name.name == "gets":
                print(f"代码调用了危险函数 行号:{i.coord.line}")
        if i.name.name == "strcpy":
                print(f"代码调用了危险函数 行号:f{i.coord.line}")

def stack_overflow_check(i,buf_name,buf_size):
    if i.name.name == "read":
        if i.args.exprs[1].name in buf_name:
                position = buf_name.index(i.args.exprs[1].name)
                position += 1
                if int(i.args.exprs[2].value,0x10) > sum(buf_size[:position]):
                    print(f"代码可能存在栈溢出漏洞 行号:{i.coord.line}")

def format_check(i):
    if i.name.name == "printf":
        if len(i.args.exprs) == 1:
            print(f"代码可能存在格式化字符串漏洞 行号:{i.coord.line}")

def c_ast():
    ast = parse_file("temp.c",use_cpp = False)
    function_name = []
    buf_size= []
    buf_name = []
    for i in ast.ext:          #记录代码定义的所有函数
        function_name.append(i.decl.name)
    for i in ast.ext:
        array_size = 0
        if i.decl.name == "main":  #先从main函数开始分析
            # print(i)
            for j in i.body.block_items:
                if isinstance(j,Decl):
                    buf_name.append(j.name)   #分别记录了main函数中定义的数组名和长度 用于后面的栈溢出判断 先定义的数组位于栈帧高地址处 所需的溢出长度较小
                    buf_size.append(int(j.type.dim.value,0x10))
                if isinstance(j,FuncCall):
                    danger_function_check(j)
                    stack_overflow_check(j,buf_name,buf_size)
                    format_check(j)
                    if j.name.name in function_name:   
                        if j.args:        #如果调用到的函数中使用了main函数定义的参数 就共享数组列表
                            for a in j.args.exprs:
                                if a.name in buf_name:
                                    position = function_name.index(j.name.name)
                                    for b in ast.ext[position].body.block_items:
                                        danger_function_check(b)
                                        stack_overflow_check(b,buf_name,buf_size)
                                        format_check(b)
                        else:             #如果调用的函数没有使用参数 就单独一个数组列表
                            buf_size = []
                            buf_name = []
                            position = function_name.index(j.name.name)
                            for b in ast.ext[position].body.block_items:
                                if isinstance(b,Decl):
                                    buf_name.append(b.name) 
                                    buf_size.append(int(b.type.dim.value,0x10))
                                if isinstance(b,FuncCall):
                                    danger_function_check(b)
                                    stack_overflow_check(b,buf_name,buf_size)  
                                    format_check(b)


def main():
    init()
    file_type = check_filetype()
    if file_type == 1:
        c_deal()
        c_ast()
    elif file_type == 2:
        python_deal()
if __name__ == "__main__":
    main()

效果演示:


有一点就是行号对不上 因为输入进去的test.c文件去除了#define和#include 缺失了部分行 这一点看看后面要不要进行优化

参考文章

https://blog.csdn.net/weixin_41238626/article/details/138434837
https://blog.csdn.net/csdnnews/article/details/105592032
https://blog.csdn.net/m0_56208280/article/details/132238997
https://blog.51cto.com/u_16213708/7081217