符号执行(1) - 自动生成覆盖率用例之利器

最新推荐文章于 2024-03-28 13:00:21 发布
最新推荐文章于 2024-03-28 13:00:21 发布
阅读量1.9k 收藏 13
点赞数 4
分类专栏： 形式化方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lusing/article/details/109083038
版权

符号执行(1) - 自动生成覆盖率用例之利器

对于安全性要求比较高的软件，为了防止出现安全漏洞，我们不得不花大量时间写更多的测试用例来提升覆盖率。尤其是高可靠性软件需要的修正条件判定覆盖MC/DC(Modified Condition/Decision Coverage)，更是要多花不少心思。

全靠手工写，工作量太大，而且重复性工作不少。靠模糊测试命中的话效率又比较低。
那么，有没有什么办法可以将这些机械的工作做得自动化一点，机器能够帮我们设计一些测试用例呢？符号执行就是一种可用的利器。

什么是符号执行

为了避免有同学望文生义，我们先解释下符号执行的含义。符号执行是借助程序的形式化语义来分析代码的一种方法，具体地说，不考虑循环的情况下，符号执行就是求解霍尔逻辑的最弱前置条件。
这里面主要的工具除了霍尔逻辑的公理外，主要还会用到可满足性模理论SMT工具。后面我们讲符号执行工具klee时大家就会看到，相当多的步骤其实我们是在准备SMT工具。

有个简单的概念之后，我们迅速进入通过例子学习的阶段。对于跟安全性打交道不多的同学来说，完全不懂Hoare Logic, SMT, SAT这些概念不影响使用符号执行工具来帮我们找出一些测试用例。

通过例子学习klee符号执行

下面我们就以klee为例来讲解下如何在工作中使用符号执行来帮我们生成测试用例。

klee是用于C/C++的符号执行工具，也有达人研究中应用于Rust等语言的用法。通过后面的例子可以看到，只要能生成llvm byte code，应该都有办法来执行。

我们先写个待测函数，将百分制的分数映射成ABCD等级：

char testscore(int score)
{
    if (score > 100)
    {
        return 'E';
    }
    else if (score < 0)
    {
        return 'E';
    }
    else if (score >= 90)
    {
        return 'A';
    }
    else if (score >= 80)
    {
        return 'B';
    }
    else if (score >= 60)
    {
        return 'C';
    }
    else
    {
        return 'D';
    }
}

既然是符号执行，我们写测试用例时不给具体值，只给一个符号，然后让klee帮我们去找该测什么值。这通过klee_make_symbolic函数来实现，我们给上面的testscore写个main函数来调用：

int main()
{
    int score;
    klee_make_symbolic(&score, sizeof(score), "score");
    return (testscore(score));
}

我们用clang来编译它，生成llvm中间代码testscore.bc:

clang -emit-llvm -c testscore.c

然后我们就调用klee去自动执行上一步编译出的字节码:

klee testscore.bc

输出如下：

KLEE: output directory is "/workspace/xulun/github/libs/klee-out-3"
KLEE: Using STP solver backend

KLEE: done: total instructions = 61
KLEE: done: completed paths = 6
KLEE: done: generated tests = 6

以上说明，总共61条指令，klee为我们发现了6个分支，并生成了覆盖这6个分支的测试用例。

我们通过klee-stats工具来看下生成的用例的覆盖率：

----------------------------------------------------------------------------
|    Path     |  Instrs|  Time(s)|  ICov(%)|  BCov(%)|  ICount|  TSolver(%)|
----------------------------------------------------------------------------
|./klee-out-3/|      61|     0.05|   100.00|   100.00|      41|       96.17|
----------------------------------------------------------------------------

我们看到，语句和分支的覆盖率都是100%，干得不错。

下面我们用ktest-tool工具来看下生成的6个测试用例的值是什么：

ktest-tool ./klee-out-3/test000001.ktest
ktest file : './klee-out-3/test000001.ktest'
args       : ['testscore.bc']
num objects: 1
object 0: name: 'score'
object 0: size: 4
object 0: data: b'\xff\xff\xff\x7f'
object 0: hex : 0xffffff7f
object 0: int : 2147483647
object 0: uint: 2147483647
object 0: text: ....
[root@7a5293f64325 libs]# ktest-tool ./klee-out-3/test000002.ktest
ktest file : './klee-out-3/test000002.ktest'
args       : ['testscore.bc']
num objects: 1
object 0: name: 'score'
object 0: size: 4
object 0: data: b'\x00\x00\x00\x80'
object 0: hex : 0x00000080
object 0: int : -2147483648
object 0: uint: 2147483648
object 0: text: ....
[root@7a5293f64325 libs]# ktest-tool ./klee-out-3/test000003.ktest
ktest file : './klee-out-3/test000003.ktest'
args       : ['testscore.bc']
num objects: 1
object 0: name: 'score'
object 0: size: 4
object 0: data: b'\x00\x00\x00\x00'
object 0: hex : 0x00000000
object 0: int : 0
object 0: uint: 0
object 0: text: ....
[root@7a5293f64325 libs]# ktest-tool ./klee-out-3/test000004.ktest
ktest file : './klee-out-3/test000004.ktest'
args       : ['testscore.bc']
num objects: 1
object 0: name: 'score'
object 0: size: 4
object 0: data: b'Z\x00\x00\x00'
object 0: hex : 0x5a000000
object 0: int : 90
object 0: uint: 90
object 0: text: Z...
[root@7a5293f64325 libs]# ktest-tool ./klee-out-3/test000005.ktest
ktest file : './klee-out-3/test000005.ktest'
args       : ['testscore.bc']
num objects: 1
object 0: name: 'score'
object 0: size: 4
object 0: data: b'<\x00\x00\x00'
object 0: hex : 0x3c000000
object 0: int : 60
object 0: uint: 60
object 0: text: <...
[root@7a5293f64325 libs]# ktest-tool ./klee-out-3/test000006.ktest
ktest file : './klee-out-3/test000006.ktest'
args       : ['testscore.bc']
num objects: 1
object 0: name: 'score'
object 0: size: 4
object 0: data: b'P\x00\x00\x00'
object 0: hex : 0x50000000
object 0: int : 80
object 0: uint: 80
object 0: text: P...

通过读取test000001.ktest到test000006.ktest这6个文件，我们发现，系统帮我们找到的score值分别为：2147483647，-2147483648，0，90，60，80。最大正值，最小负值和0都被考虑到了，还有代码中区分不同分支的60,80,90都被自动找到了。

两个参数的例子

单找一个参数不过瘾，我们再来试试两个参数的。
先来个最简单的，求两个数的最大值吧：

#include "klee/klee.h"

int max2(int a, int b){
    if(a>b){
        return a;
    }else{
        return b;
    }
}

int main()
{
    int a,b;
    klee_make_symbolic(&a, sizeof(a), "a");
    klee_make_symbolic(&b, sizeof(b), "b");
    return (max2(a,b));
}

老办法，编译成bc字节码：

clang -emit-llvm -c max.c

然后运行klee max.bc:

klee max.bc
KLEE: output directory is "/workspace/xulun/github/libs/klee-out-4"
KLEE: Using STP solver backend

KLEE: done: total instructions = 32
KLEE: done: completed paths = 2
KLEE: done: generated tests = 2

这个只有两个分支，所以klee给我们也就找到两个。
再用klee-stats看下覆盖率：

# klee-stats ./klee-out-4/
----------------------------------------------------------------------------
|    Path     |  Instrs|  Time(s)|  ICov(%)|  BCov(%)|  ICount|  TSolver(%)|
----------------------------------------------------------------------------
|./klee-out-4/|      32|     0.00|   100.00|   100.00|      29|       65.62|
----------------------------------------------------------------------------

带循环的例子

下面我们再挑战个复杂点的例子，带循环结构的例子。
我们以辗转相除法求最大公约数为例子吧：

#include "klee/klee.h"

short gcd(short a, short b){
    short a0 = a;
    short b0 = b;
    short c0 = 0;
    if(a<=0 || b<=0){
        return 0;
    }

    if(a<b){
        a0 = b;
        b0 = a;
    }

    for(;;){
        c0 = a0 % b0;
        if(c0==0){
            return b0;
        }else{
            a0 = b0;
            b0 = c0;
        }
    }

    return 1;
}

int main()
{
    short a,b;
    klee_make_symbolic(&a, sizeof(a), "a");
    klee_make_symbolic(&b, sizeof(b), "b");
    return (gcd(a,b));
}

大家看到，这个例子我们没用int类型，而是使用的short，这样是因为int需要运行的时间较长，光short类型klee就为我们发现了44个case，大约会占满一个CPU核几分钟左右。

klee gcd2.bc
KLEE: output directory is "/workspace/xulun/github/libs/klee-out-5"
KLEE: Using STP solver backend

KLEE: done: total instructions = 1431
KLEE: done: completed paths = 44
KLEE: done: generated tests = 44

我们看下coverage:

# klee-stats ./klee-out-5/
----------------------------------------------------------------------------
|    Path     |  Instrs|  Time(s)|  ICov(%)|  BCov(%)|  ICount|  TSolver(%)|
----------------------------------------------------------------------------
|./klee-out-5/|    1431|   212.26|    98.75|    90.00|      80|       99.99|
----------------------------------------------------------------------------

因为这个是测试最大公约数，klee能够帮助我们生成例子能帮我们省不少事。
因为a和b都是0的case已经可以cover到a<=0 || b<=0这一分支，所以klee除了第一个case是0，0之外，后面全是正的有效例子。
第一个是0,0:

ktest-tool ./klee-out-6/test000001.ktest
ktest file : './klee-out-6/test000001.ktest'
args       : ['gcd3.bc']
num objects: 2
object 0: name: 'a'
object 0: size: 2
object 0: data: b'\x00\x00'
object 0: hex : 0x0000
object 0: int : 0
object 0: uint: 0
object 0: text: ..
object 1: name: 'b'
object 1: size: 2
object 1: data: b'\x00\x00'
object 1: hex : 0x0000
object 1: int : 0
object 1: uint: 0
object 1: text: ..

全部44次的值如下：

轮数ab
100
210
311
413
523
625592
757
83131765
9410216405
102048212289
1165738204
1232601143
1325896038
14325114192
15378316384
162061011838
172152428799
18227741444
192470431937
202458716044
212596126699
221980517422
232351625899
24130777540
251865328171
263257720000
271993232107
283262226737
291929026657
302700916386
311907429917
322346732422
332826617443
341958431685
353150519452
362977918406
371541324939
382582915969
392865517709
402004132428
411584125631
422563315842
431771128657
442865717711

数组和字符串的例子

我们来个字符串的例子，因为不是测库函数，所以没有调用库函数。其实klee_make_symbolic本来就是为数组设计的，我们只要把数组大小传给第2个参数就可以了：

#include "klee/klee.h"

int check_pass(char* a){
    if(a==NULL){
        return -1;
    }else if(a[0]=='\0'){
        return -2;
    }else{
        if(a[0]=='C' && a[1]=='+' && a[2]=='+'){
            return 1;
        }else{
            return 0;
        }
    }
}

#define LEN 3

int main()
{
    char secret[LEN];
    klee_make_symbolic(&secret, LEN, "secret");
    return (check_pass(secret));
}

klee为我们找到5个分支，分别是：0开头的，非0非C开头的，C开头的, C+开头的, C++ 5种：

[root@7a5293f64325 libs]# ktest-tool ./klee-out-7/test000001.ktest
ktest file : './klee-out-7/test000001.ktest'
args       : ['strc.bc']
num objects: 1
object 0: name: 'secret'
object 0: size: 3
object 0: data: b'\x00\x00\x00'
object 0: hex : 0x000000
object 0: text: ...
[root@7a5293f64325 libs]# ktest-tool ./klee-out-7/test000002.ktest
ktest file : './klee-out-7/test000002.ktest'
args       : ['strc.bc']
num objects: 1
object 0: name: 'secret'
object 0: size: 3
object 0: data: b'\x01\xff\xff'
object 0: hex : 0x01ffff
object 0: text: ...
[root@7a5293f64325 libs]# ktest-tool ./klee-out-7/test000003.ktest
ktest file : './klee-out-7/test000003.ktest'
args       : ['strc.bc']
num objects: 1
object 0: name: 'secret'
object 0: size: 3
object 0: data: b'C\x00\xff'
object 0: hex : 0x4300ff
object 0: text: C..
[root@7a5293f64325 libs]# ktest-tool ./klee-out-7/test000004.ktest
ktest file : './klee-out-7/test000004.ktest'
args       : ['strc.bc']
num objects: 1
object 0: name: 'secret'
object 0: size: 3
object 0: data: b'C+\x00'
object 0: hex : 0x432b00
object 0: text: C+.
[root@7a5293f64325 libs]# ktest-tool ./klee-out-7/test000005.ktest
ktest file : './klee-out-7/test000005.ktest'
args       : ['strc.bc']
num objects: 1
object 0: name: 'secret'
object 0: size: 3
object 0: data: b'C++'
object 0: hex : 0x432b2b
object 0: text: C++

编译安装klee

展示了klee的能力之后，很多同学跃跃欲试想一试身手了。建议初试身手时在ubuntu Linux上尝试。

klee因为其复杂性，依赖比较多。除了llvm,cmake之类的通用依赖之外，我们还需要为其编译SAT求解器minisat和SMT求解器stp。

为了让文章简单，下面的步骤都取了极简的步骤。后面我们还会编译更复杂依赖的klee。

下载编译minisat

minisat是一种SAT-布尔可满足性理论求解器。后面会介绍SAT的原理，包括DPLL, CDCL方法等。

git clone https://github.com/stp/minisat.git
cd minisat
mkdir build
cd build
sudo make install

下载编译stp

STP是基于minisat的SMT-可满足性模理论求解器。

git clone https://github.com/stp/stp.git
cd stp
mkdir build
cd build
cmake ..
make
sudo make install

下载编译klee

下面是极简步骤，后面我们还会增加库和加上测试。

git clone https://github.com/klee/klee.git
mkdir build
cd build
cmake -DENABLE_UNIT_TESTS=OFF -DENABLE_SYSTEM_TESTS=OFF ..
make
sudo make install

好了，现在klee命令可用了，大家就可以用自己的代码做实验了：）

Jtag特工
关注
专栏目录
符号执行工具-Python开发
05-25
Manticore Manticore是用于分析智能合约和二进制文件的符号执行工具。 注意：从0.2.0版开始，需要Python 3.6+。 输入生成功能：Manticore Manticore Manticore是用于分析智能合约和二进制文件的符号执行工具。 功能程序探索：Manticore可以执行带有符号输入的程序并探索其可能达到的所有状态输入生成：Manticore可以自动产生具体输入，从而导致给定的程序状态错误发现：Manticore可以检测二进制文件中的崩溃和其他故障情况和智能合约工具：Manticore提供细粒度
manticore：符号执行工具
02-05
Manticore Manticore是用于分析智能合约和二进制文件的符号执行工具。 产品特点 程序探索：Manticore可以执行带有符号输入的程序，并探索其可能达到的所有状态 输入生成：Manticore可以自动产生具体输入，从而产生给定的程序状态 错误发现：Manticore可以检测二进制文件和智能合约中的崩溃和其他故障情况 工具：Manticore通过事件回调和指令挂钩提供对状态探索的细粒度控制 程序接口：Manticore通过Python API公开对其分析引擎的程序访问 Manticore可以分析以下类型的程序： 以太坊智能合约（EVM字节码） Linux ELF二进制文件（
[符号执行-入门1]软件测试中的符号执行
weixin_34307464的博客
08-21 893
最近在自学符号执行，因此，这篇经典文章(Symbolic Execution for Software Testing: Three Decades Later)[1]作为入门必读。 0. 定义 1. 经典的符号执行 2. 现代符号执行技术 2-1. 混合执行测试(Concolic testing) 2-2. 执行生成测试(Execution-Generated Testing, EGT) ...
符号化执行 symbolic execute , klee 测试用例生成 增删改（自动化白盒测试范畴）
_
04-06 467
# 运行 sh -x ./runme.sh busz_save_activity 2>&1 | tee busz_save_activity.log sh -x ./runme.sh busz_user_activity 2>&1 | tee busz_user_activity.log // busz_save_activity.c #include "common.h" int main() { int result = false; Activi.
klee, KLEE符号执行引擎.zip
09-18
klee, KLEE符号执行引擎 KLEE符号虚拟机 KLEE 是构建在LLVM编译器基础之上的一个符号虚拟机。 目前，主要有两个组件：核心符号虚拟机引擎；负责执行带有符号值支持的LLVM位码模块。 这由 lib/中的代码组成。面向支持of的posix/li
klee:KLEE符号执行引擎
04-28
KLEE符号虚拟机 KLEE是建立在LLVM编译器基础结构之上的符号虚拟机。 当前，有两个主要组件： 核心符号虚拟机引擎； 这负责执行支持符号值的LLVM位代码模块。 这由lib /中的代码组成。 面向支持uClibc的POSIX / Linux仿真层，另外还提供了使部分操作系统环境具有符号性的支持。 另外，有一个简单的库可用于重放本机代码上的计算输入（适用于封闭程序）。 还有一个更复杂的基础结构，用于重放为POSIX / Linux仿真层生成的输入，该层处理与计算的测试输入匹配的环境中正在运行的本机程序，包括设置文件，管道，环境变量和传递命令行参数。 有关更多信息，请参见。
软件测试知识体系图谱
weixin_50552058的博客
07-07 4918
软件测试基础图谱
模糊测试--强制性安全漏洞发掘
热门推荐
软件性能测试专栏
01-20 2万+
文档分享地址链接：http://pan.baidu.com/share/link?shareid=2723797392&uk=2485812037 密码：r43x 前 言 我知道"人类和鱼类能够和平共处" 。 --George W. Bush, 2000年9月29日 简介 模糊测试的概念至少已经流传了20年，但是直到最近才引起广泛的关注。安全漏洞困扰了许多流行的客户端应用程序
大数据技术之_19_Spark学习_07_Spark 性能调优 + 数据倾斜调优 + 运行资源调优 + 程序开发调优 + Shuffle 调优 + GC 调优 + Spark 企业应用案例
黑泽君
05-04 2044
大数据技术之_19_Spark学习_07_Spark 性能调优 + 数据倾斜调优 + 运行资源调优 + 程序开发调优 + Shuffle 调优 + GC 调优 + Spark 企业应用案例
AFL模糊测试工具简介与原理解析
AFL通过自动生成测试用例，并不断地输入这些测试用例来探索目标程序的潜在漏洞，是一种自动化的测试工具。相比传统的手动测试和基于规则的测试，AFL能够更加高效地发现程序中的异常行为，提升软件的质量。 ## 1.2
符号执行简介
01-02
对符号执行技术及其相关工具KLEE的简介
基于大语言模型的智能问答系统设计与实践【系列文章】
最新发布
AI架构设计之禅
03-28 2032
随着人工智能技术的迅猛发展，智能问答系统在各行各业中得到了广泛应用。无论是智能客服、在线教育，还是智能助手，问答系统都在提升用户体验和服务效率方面发挥着重要作用。然而，传统的问答系统往往依赖于规则和模板，难以应对复杂多变的用户需求，且开发成本高，维护难度大。近年来，大规模预训练语言模型（Large Language Models, LLMs）的出现，为智能问答系统带来了新的解决方案。
符号执行，从漏洞扫描到自动化生成测试用例
IDEAL Garden
07-12 486
###背景 ThoughtWorks安全团队曾经在可信Frimware领域做了一些探索和研究。背景大概是这样的：整车制造过程中，常常会引入供应商的部分设备，如车载娱乐系统，但是出于知识产权的原因，这些供应商很难提供完整的源码给整车制造方，因此二进制的固件就成了整车制造环节中的安全隐患，各种漏洞都可能被供应商的零部件引入，存在于车载系统之中，随时可能被攻击者利用而影响整车的安全性。 为了探测二进制程序中的漏洞，经过一段时间的探索和研究后，把核心技术锁定到了符号执行，利用该技术帮客户搭建了一套自动化的二进制漏洞
符号执行工具KLEE安装
zehuac的博客
07-10 1820
系统环境 VMware workstations 10.0 Ubuntu-14.04-desktop-amd64 RAM：4GB ROM：50GB CPU：Intel-i7-4core 1. 安装步骤按照官方安装文档Build KLEE with LLVM3.4来就行2. 注意事项2.1 .bashrc文件在~/.bashrc直接gedit ~/.bashrc便可编辑 2.2 第4部Build u
符号测执行软件测试,基于符号执行与模糊测试的混合测试方法
weixin_42514222的博客
07-22 1818
1 引言随着信息技术的发展, 软件已经渗透到现代社会的方方面面, 而由于开发不当引入的软件漏洞也日益增多.据统计, 最近5年内软件漏洞数增加了38%, 而仅在2016年~2017年间就增加了14%[.软件测试是检测软件漏洞的一种主要方法, 当前工业界的主流方法还是通过手工设计测试用例来提高软件产品的质量, 然而, 手工生成测试用例通常效率较低、成本高昂并且容易出错[.每年成千上亿的资金被投入到软件...
c++ 符号执行顺序小例子
weixin_30610755的博客
03-20 105
if ( a[i] == b[i] && ++i < 0) 这个表达式的执行顺序 1. int i = 0; if ( i++ <= 0 )// 输出 True cout<<"True"<<endl; else cout<<"False"<<endl; ...
KLEE 符号执行工具的有趣实例_codestorm_新浪博客
codestrom04
03-23 1424
转自：https://feliam.wordpress.com/2010/10/07/the-symbolic-maze/ In this post we’ll exercise the symbolic execution engine KLEE over a funny ASCII Maze (yet another toy example)! VS. ...
学习驱动的复杂软件符号执行
pl_lab_001的博客
02-02 1388
本文基于卜磊老师在 SIG-程序分析技术沙龙的分享进行整理，介绍了学习驱动的复杂软件符号执行，视频也已经发布在 B 站，欢迎学习。
KLEE 使用（二）------ 怎么自动地生成测试用例？
qq_21746331的博客
09-24 1123
在这篇博客中，我们将展示如何使用 KLEE 自动地为一些整数相关的小实例（用 C 语言编写）生成测试用例，在下篇博客中，我们将用 KLEE 来测试一段二分查找算法的代码，生成测试用例。 符号执行是不同于实际运行程序的，在符号执行中，我们跟踪的不是变量的实际值，而是其“符号值”和对这些值的操作。所以，对于如下这段函数代码： int many_math_operations(int x) { int result = x * 2; result += 5; result /= -3;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jtag特工

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值