符号化执行 symbolic execute , klee 测试用例生成 增删改（自动化白盒测试范畴）

已于 2022-02-21 17:58:58 修改
阅读量446 收藏 2
点赞数 1
分类专栏： klee 文章标签： 白箱测试 软件测试
于 2021-04-06 17:14:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hfcaoguilin/article/details/115465424
版权

gitee仓库 分支cgl-dev


# 运行

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;

	Activity activity1;
	// strcpy(activity1.name, "zs");
	// activity1.shopId = 1;
	// activity1.on = 1;


	Activity activity2;
	// strcpy(activity2.name, "LS");
	// activity2.shopId = 1;
	// activity2.on = 1;

	// printRow_activity(&activity1,"init_1");
	klee_make_symbolic(&activity1, sizeof(activity1), "activity1");
	// printRow_activity(&activity1,"init_2");
	klee_assume(assume_fieldInList_activity_name(&activity1));
	klee_assume(assume_fieldInList_activity_shopId(&activity1));
	klee_assume(assume_fieldInList_activity_on(&activity1));
    
	klee_make_symbolic(&activity2, sizeof(activity2), "activity2");
	klee_assume(assume_fieldInList_activity_name(&activity2));
	klee_assume(assume_fieldInList_activity_shopId(&activity2));
	klee_assume(assume_fieldInList_activity_on(&activity2));
    
	// klee_make_symbolic(&activityTabCurId, sizeof(activityTabCurId), "activityTabCurId");
	// klee_make_symbolic(&activityTabCurIndex, sizeof(activityTabCurIndex), "activityTabCurIndex");
	// klee_make_symbolic(&activityTab, sizeof(activityTab), "activityTab");
	// klee_assume(isValidActivity(&activity));
	// klee_assume(internalCheckTableValidated_activity());
	// printRow_activity(&activity1,"before_api_save_row_activity");
	result = api_save_row_activity(&activity1);
	// printRow_activity(&activity1,"after_api_save_row_activity");
	assert(result == OK);
	
	// printRow_activity(&activity2,"before_api_save_row_activity");
	result = api_save_row_activity(&activity2);
	// printRow_activity(&activity2,"after_api_save_row_activity");
	assert(result == OK);

	// for(int i = 1; i < TableMaxRow-1; i++){

	// result = api_save_row_activity(&activity);
	// printf("result = %d\n", result);
	// assert(result == OK);
	// }
	return 0;
}






//examples/crud/busz_user_activity.c

#include "common.h"
bool bothTrue(bool user1HasActivityFirst,bool user1HasActivitySecond){
    if(user1HasActivityFirst==true){
        if(user1HasActivitySecond==true){
            return true;
        } 
    }else {
        return false;
    }        
}
bool oneTrue(bool user1HasActivityFirst,bool user1HasActivitySecond){
    if(user1HasActivityFirst==true){
        return true;
    }else
    if(user1HasActivitySecond==true){
        return true;
    }
    else {
        return false;
    }        
}
int main() {
	bool saveActivity1Result = false;
	bool saveActivity2Result = false;
	bool user1HasActivityFirst = false;
	bool user1HasActivitySecond = false;
	int user1ScoreFirst = ScoreNotValidated1;
	int user1ScoreSecond = ScoreNotValidated2;//make sure user1ScoreFirst!=user1ScoreSecond
	Activity* pActivityUser1First=NULL;
	Activity* pActivityUser1Second=NULL;

	Activity activity1;

	Activity activity2;

	User user1;


	// printRow_activity(&activity1,"init_1");
	klee_make_symbolic(&activity1, sizeof(activity1), "activity1");
	// printRow_activity(&activity1,"init_2");
	klee_assume(assume_fieldInList_activity_name(&activity1));
	klee_assume(assume_fieldInList_activity_shopId(&activity1));
	klee_assume(assume_fieldInList_activity_on(&activity1));
	klee_assume(assume_fieldInList_activity_newUserScore(&activity1));
	klee_assume(assume_fieldInList_activity_oldUserScore(&activity1));
	klee_assume(assume_betweenFields_activity_newOldUserScoreNotEqual(&activity1));
	// klee_assume(assume_fieldsConstraint_activity_beginDt_endDt( &activity1 ));
    
	klee_make_symbolic(&activity2, sizeof(activity2), "activity2");
	klee_assume(assume_fieldInList_activity_name(&activity2));
	klee_assume(assume_fieldInList_activity_shopId(&activity2));
	klee_assume(assume_fieldInList_activity_on(&activity2));
	klee_assume(assume_fieldInList_activity_newUserScore(&activity2));
	klee_assume(assume_fieldInList_activity_oldUserScore(&activity2));
	klee_assume(assume_betweenFields_activity_newOldUserScoreNotEqual(&activity2));
    
	klee_make_symbolic(&user1, sizeof(user1), "user1");
	klee_assume(assume_fieldInList_user_phone(&user1));
	klee_assume(assume_fieldInList_user_shopId(&user1));
    
	// printRow_activity(&activity1,"before_api_save_row_activity");
	saveActivity1Result = api_save_row_activity(&activity1);
	// printRow_activity(&activity1,"after_api_save_row_activity");
	assert(saveActivity1Result == OK);
	
	// printRow_activity(&activity2,"before_api_save_row_activity");
	saveActivity2Result = api_save_row_activity(&activity2);
	// printRow_activity(&activity2,"after_api_save_row_activity");
	assert(saveActivity2Result == OK);


    
    // printRow_user(&user1,"before_api_hasActivity_1");
	user1HasActivityFirst = api_hasActivity(&user1,&pActivityUser1First);
    printf("user1HasActivityFirst:%d\n", user1HasActivityFirst);
    if(pActivityUser1First!=NULL){
        printRow_activity(pActivityUser1First,"pActivityUser1First");
    }
    // printRow_user(&user1,"after_api_hasActivity_1");
	if(user1HasActivityFirst==true){
		user1ScoreFirst=api_joinActivity(&user1);
        sql_selectTable_user_print();
        // printRow_user(&user1,"after_api_joinActivity_1");
	}

    // printRow_user(&user1,"before_api_hasActivity_2");
	user1HasActivitySecond = api_hasActivity(&user1,&pActivityUser1Second);
    printf("user1HasActivitySecond:%d\n", user1HasActivitySecond);
    if(pActivityUser1Second!=NULL){
        printRow_activity(pActivityUser1Second,"pActivityUser1Second");
    }
    // printRow_user(&user1,"after_api_hasActivity_2");
	if(user1HasActivitySecond==true){
		user1ScoreSecond=api_joinActivity(&user1);
        // printRow_user(&user1,"after_api_joinActivity_2");
	}
    
	klee_assume(oneTrue(user1HasActivityFirst,user1HasActivitySecond));
    
    sql_selectTable_activity_print();
    sql_selectTable_user_print();
    
    printf("user1ScoreFirst:%d,user1ScoreSecond:%d\n", user1ScoreFirst, user1ScoreSecond);
    
    if(user1HasActivityFirst==true){
	if(user1HasActivitySecond==true){
        assert(user1ScoreFirst != user1ScoreSecond);
    }
    }
	
	return 0;
}


//common.h


#include <klee/klee.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <time.h>

#define bool int
#define true 1
#define false 0


#define IdNotValidated -2
#define TableMaxRow 10

#define OK 0

#define ErrOutOfTableMaxRow 1
#define ErrBreakTableConstraint 2




#define STR_MAX_LEN 12

//{table Activity :  java or mysql.table or sql
#define Score1 3 
#define Score2 29
#define Score3 7 
#define Score4 31 
#define ScoreNotValidated1 -101
#define ScoreNotValidated2 -103

#define ActivityTypeNull 0
#define FirstId 1

struct _Activity {
	int id;
	char name[STR_MAX_LEN];
	bool on;//0,1
	int newUserScore;//3
	int oldUserScore;//11
	int shopId;//0:NULL,1,2,3
};

typedef struct _Activity Activity;

Activity* activityTab[TableMaxRow];
int activityTabCurIndex = -1;
int activityTabCurId = FirstId;

void printRow_activity(Activity * pa,char* msg) {
	printf(" %s :: activity: {id:%d, name:%s, shopId:%d, on:%d, newUserScore:%d, oldUserScore:%d} ; \n", msg,pa->id, pa->name, pa->shopId, pa->on, pa->newUserScore, pa->oldUserScore   );
}

int internalCheckTableValidated_activity() {
	for (int i = 0; i <= activityTabCurIndex - 1; i++) {
		for (int k = i + 1; k <= activityTabCurIndex; k++) {
			assert (activityTab[i]->id != activityTab[k]->id);// non repeated id
			assert (strcmp(activityTab[i]->name, activityTab[k]->name) != 0) ; // non repeated name
		}
	}
	return true;
}

Activity* sql_selectOneRowFromTableWhere_activity_shopId(int shopId){
	for (int i = 0; i <= activityTabCurIndex - 1; i++) {
			if (activityTab[i]->shopId == shopId){
                return activityTab[i];
            }
	}
	return NULL;
}

void sql_selectTable_activity_print(){
    printf("sql_selectTable_activity_print__[\n");
	for (int i = 0; i <= activityTabCurIndex ; i++) {
        printRow_activity(activityTab[i],"sql_selectTable_activity_print");
	}
    printf("]\n");
}
//}

//{table User : may generate from java or mysql.table 
#define UserTableMaxRow 10

struct _User {
	int id;
	char phone[STR_MAX_LEN];
	int shopId;//0:NULL,1,2,3
};

typedef struct _User User;

User* userTab[TableMaxRow];
int userTabCurIndex = -1;
int userTabCurId = FirstId;

void printRow_user(User * p,char* msg) {
    if(p==NULL){
        printf("%s:null\n",msg);
    }else{
        
	printf(" %s :: user: {id:%d, phone:%s, shopId:%d } ; \n", msg,p->id, p->phone , p->shopId);
    }
}

int internalCheckTableValidated_user() {
	for (int i = 0; i <= userTabCurIndex - 1; i++) {
        // printRow_user(userTab[i],"internalCheckTableValidated_user_loop");
		for (int k = i + 1; k <= userTabCurIndex; k++) {
            // printRow_user(userTab[i],"internalCheckTableValidated_user_i");
            // printRow_user(userTab[k],"internalCheckTableValidated_user_k");
			assert (userTab[i]->id != userTab[k]->id);// non repeated id
			assert (strcmp(userTab[i]->phone, userTab[k]->phone) != 0) ; // non repeated phone
		}
	}
	return true;
}

User* sql_selectOneRowFromTableWhere_user_phone(char* phone){
	for (int i = 0; i <= userTabCurIndex ; i++) {
			if (strcmp(userTab[i]->phone,phone)==0){
                return userTab[i];
            }
	}
	return NULL;
}

void sql_selectTable_user_print(){
    printf("sql_selectTable_user_print__[\n");
	for (int i = 0; i <= userTabCurIndex ; i++) {
        printRow_user(userTab[i],"sql_selectTable_user_print");
	}
    printf("]\n");
}
//}

//{ common assume : input field assume , included in java or : assuming in list not influence java execute result
bool assume_fieldInList_shopId(int shopId){
    if(shopId==FirstId){
        return true;
    }else
    if(shopId==FirstId+1){
        return true;
    }else
    // if(shopId==2){
        // return true;
    // }else
    if(shopId==FirstId+1+1){
        return true;
    }else
    {
        return false;
    }
}
//}

bool assume_fieldInList_activity_score(int score){
    if(score==Score1){
        return true;
    }else
    if(score==Score2){
        return true;
    }else
    if(score==ScoreNotValidated1){
        return false;
    }else
    if(score==ScoreNotValidated2){
        return false;
    }else
    {
        return false;
    }
}

//{ Activity assume : input field assume , included in java



bool assume_fieldInList_activity_name(Activity *pa){
    char* name=pa->name;
    if(strcmp(name,"Actv.1")==0){
        return true;
    }else
//    if(strcmp(name,"LiSi")==0){
//        return true;
//    }else
    if(strcmp(name,"Actv.2")==0){
        return true;
    }else{
        return false;
    }
}

bool assume_fieldInList_activity_shopId(Activity *p){
    return assume_fieldInList_shopId(p->shopId);
}


bool assume_fieldInList_activity_on(Activity *pa){
    bool on=pa->on;
    if(on==true){
        return true;
    }else
    if(on==false){
        return true;
    }else
    {
        return false;
    }
}

bool assume_fieldInList_activity_newUserScore(Activity *pa){
   return assume_fieldInList_activity_score(pa->newUserScore);
}

bool assume_fieldInList_activity_oldUserScore(Activity *pa){
   return assume_fieldInList_activity_score(pa->oldUserScore);
}



bool assume_betweenFields_activity_newOldUserScoreNotEqual(Activity *pActivity1){
    if(pActivity1->newUserScore != pActivity1->oldUserScore){
        return true;
    }else{
        return false;
    }
}

//}

//{ other 

//}


//{User service : simulate mysql.table and java insert sql
int service_save_row_user(User *pa) {
	if (userTabCurIndex >= TableMaxRow) {
		return ErrOutOfTableMaxRow;
	}
	userTabCurIndex++;
	userTabCurId++;
	pa->id = userTabCurId;
	userTab[userTabCurIndex] = pa;
	if (internalCheckTableValidated_user()==false) {
        printf("revert_service_save_row_user\n");
		userTabCurIndex--;
		userTabCurId--;
		return ErrBreakTableConstraint;
	}
	else {
		return OK;
	}
}



//}

//{Activity api : simulate mysql.table and java insert sql
bool api_save_row_activity(Activity *pa) {
	if (activityTabCurIndex >= TableMaxRow) {
		return ErrOutOfTableMaxRow;
	}
	activityTabCurIndex++;
	activityTabCurId++;
	pa->id = activityTabCurId;
	activityTab[activityTabCurIndex] = pa;
	if (internalCheckTableValidated_activity()==false) {
		activityTabCurIndex--;
		activityTabCurId--;
		return ErrBreakTableConstraint;
	}
	else {
		return OK;
	}
}

bool api_hasActivity(User* p,Activity** ppaReturn){
    Activity* pa = sql_selectOneRowFromTableWhere_activity_shopId(p->shopId);
    if(pa==NULL){
        return false;
    }
    if(pa->on==false){
        return false;
    }
    if(ppaReturn!=NULL){
        (*ppaReturn) = pa;
    }
    return true;    
}

int api_joinActivity(User* pUser){
    Activity* pActivity=NULL;
    User* pUserFromTab =NULL;
    
    bool hasActivity = api_hasActivity(pUser,&pActivity);
    if(hasActivity==false){
        return false;
    }
    assert(pActivity!=NULL);//internal error in api_hasActivity
    
    pUserFromTab = sql_selectOneRowFromTableWhere_user_phone(pUser->phone);
    // printRow_user(pUserFromTab,"pUserFromTab");
    // printRow_activity(pActivity,"pActivity_api_joinActivity");
    
    if(pUserFromTab==NULL){
        //service_save_row_user(pUser);
        return pActivity->newUserScore;
    }else{
    return pActivity->oldUserScore;    
    }
    
}


//}




//{ User assume : input field assume , included in java or : assuming in list not influence java execute result
bool assume_fieldInList_user_phone(User *p){
    char* phone=p->phone;
    if(strcmp(phone,"13000000000")==0){
        return true;
    }else
    if(strcmp(phone,"18688888888")==0){
        return true;
    }else{
        return false;
    }
}


bool assume_fieldInList_user_shopId(User *p){
    return assume_fieldInList_shopId(p->shopId);
}


//}






#runme.sh

#run me: 
#sh -x  ./runme.sh insert  2>&1 | tee  run.log

rm -fr *.out *.bc klee* *elf*

target=$1

echo "$target.c-->$target.bc"
clang -I /root/klee/include -emit-llvm -c -g -O0 -Xclang -disable-O0-optnone $target.c

echo "$target.bc-->klee-last(test case)"
# klee --external-calls=all   --libc=uclibc --posix-runtime --smtlib-human-readable   $target.bc
klee --external-calls=all   --libc=uclibc --posix-runtime --solver-backend=z3  $target.bc

echo "$target.c-->$target.elf_eat_test_case"
gcc -I /root/klee/include   $target.c -lkleeRuntest -o $target.elf_eat_test_case
ls -1 klee-last/*.ktest | awk '{printf("  KTEST_FILE=%s ./$target.elf_eat_test_case\n",  $0)}' | sh -x
ziix
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
符号执行，从漏洞扫描到自动化生成测试用例
IDEAL Garden
07-12 464
###背景 ThoughtWorks安全团队曾经在可信Frimware领域做了一些探索和研究。背景大概是这样的：整车制造过程中，常常会引入供应商的部分设备，如车载娱乐系统，但是出于知识产权的原因，这些供应商很难提供完整的源码给整车制造方，因此二进制的固件就成了整车制造环节中的安全隐患，各种漏洞都可能被供应商的零部件引入，存在于车载系统之中，随时可能被攻击者利用而影响整车的安全性。 为了探测二进制程序中的漏洞，经过一段时间的探索和研究后，把核心技术锁定到了符号执行，利用该技术帮客户搭建了一套自动化的二进制漏洞
klee:KLEE符号执行引擎
04-28
KLEE符号虚拟机 KLEE是建立在LLVM编译器基础结构之上的符号虚拟机。 当前，有两个主要组件： 核心符号虚拟机引擎； 这负责执行支持符号值的LLVM位代码模块。 这由lib /中的代码组成。 面向支持uClibc的POSIX / Linux仿真层，另外还提供了使部分操作系统环境具有符号性的支持。 另外，有一个简单的库可用于重放本机代码上的计算输入（适用于封闭程序）。 还有一个更复杂的基础结构，用于重放为POSIX / Linux仿真层生成的输入，该层处理与计算的测试输入匹配的环境中正在运行的本机程序，包括设置文件，管道，环境变量和传递命令行参数。 有关更多信息，请参见。
p4pktgen:用于P4程序的自动测试用例生成器
05-03
p4蛋白 介绍 p4pktgen是用于为覆盖程序所有路径的P4程序生成输入数据包和表条目的工具。 它支持使用该语言的P4_14或P4_16变体编写的程序，只要该程序可以使用开源p4c-bm2-ss编译器（ 存储库的一部分）进行编译，然后编译为bmv2 JSON文件以供使用即可。 simple_switch软件开关（ 存储库的一部分）。 当前，它涵盖了通过解析器和入口控制块的执行路径的所有组合，但忽略了出口控制块。 它在simple_switch运行测试用例，以检查数据包是否遵循预期的执行路径，并写出一个描述测试用例的数据文件，这对于在其他P4实现上执行测试用例应该是有用的（调整测试用例以使其在其他实现上运行）。 先决条件 Python 3.6，pip 来自项目的simple_switch 安装p4c和simple_switch ，有一个由Andy芬格赫特。 确保simple_swi
Klee
03-10
/ 克利一号 Klee是一种用铅笔或钢笔手写的脚本字体。 它的安静设计具有优雅的外观，使其与传统的脚本和教科书字体区分开来。 正文的理想选择。 。 下载字体 您可以从下一页下载预构建的TrueType字体。 从源代码构建字体 要求 建立字体 将当前工作目录更改为“ Klee”文件夹，然后运行build.py 。 $ python build.py 执照 该字体已获得。 人物 所有字形 禁止行为 除“ SIL Open Font License Version 1.1”（SIL开放字体许可版本1.1）以外，根据许可重新分发。 出售字体文件本身。
自动生成测试用例?--带你走进Klee之路
最新发布
geekchen的博客
05-10 979
符号执行(Symbolic Execution) 属于静态分析的一种，e.g.对于函数a = malloc(), 符号执行会赋值一个符号$a 来代表 a的值,通过流程图模拟执行,而非实际执行.
KLEE入门教程
qq_26736193的博客
12-09 4134
本文1.首先介绍创建KLEE Docker容器的方法；2.然后介绍官网给出的一个指导实例；3.最后给出程序测试实例。 创建KLEE Docker容器 相关Dokcer的知识可以参见官网：https://docs.docker.com/get-started/ 1.创建临时KLEE Docker容器 $ docker run --rm -ti --ulimit='stack=-1:-1' ...
klee源码阅读笔记1--STPBuilder类
weixin_30449453的博客
05-29 192
初始化过程中四个数据成员中的两个数据成员被初始化： 一、vc被初始化为STP提供的C调用接口函数vc_createValidityChecker()； 二、optimizeDivides被初始化为false 重点探讨另外两个数据成员。 一、ExprHashMap constructed ExprHashMap< std::pair<ExprHandle, unsign...
KLEE--KQuery
fjnuzs的博客
03-22 1013
 KQuery是约束表达式和约束查询的文本表示，Kleaver约束求解器以其为输入。该语言能够表示基于位向量和数组的自由量词公式，它可以直接支持位向量的标准操作。该语言具有很好的读写交互，并且和C++ API有非常紧密的关系。    因为是一边看一边翻译，所以有些不理解，也就只能字面意义了。文档不够详细，也没有例子，后面有时间搞清楚了我会在进行文档的修改。    原文：http://klee....
KLEE学习——实例1
qq_26736193的博客
07-06 2182
下面开始根据KLEE官方给出的示例进行学习，闲话不多说，开始第一个示例的学习：Testing a small function 这个例子是引导我们熟悉使用klee测试简单函数所需的主要步骤，代码在/examples/get_sign目录下. 简单函数的代码如下，判断x的是0、正数、还是负数。 int get_sign(int x) { if (x == 0) return 0; if (x < 0) return -1; else return 1;} 主要分
黑盒测试与白盒测试
a26637896的博客
01-17 1349
黑盒测试与白盒测试
在idea中创建maven工程，搭建mybatis框架
qq_46062119的博客
09-10 397
在idea中创建maven工程，搭建mybatis框架 一.创建Maven项目 1.选择 File--> New--> Project 2.选择Maven-->选择自己的JDK版本--> Next 3.创建项目名，并定义项目存放位置--> Finish 二.Maven基础配置 1.创建好Maven项目后，打开Maven项目中的pom.xml文件，加载所需要的jar包； 2.在pom.xml文件中找到 </properties>结束标签，在下一行添加所需要的依
符号执行(1) - 自动生成覆盖率用例之利器
lusing的专栏
10-14 1843
符号执行(1) - 自动生成覆盖率用例之利器 对于安全性要求比较高的软件，为了防止出现安全漏洞，我们不得不花大量时间写更多的测试用例来提升覆盖率。尤其是高可靠性软件需要的修正条件判定覆盖MC/DC(Modified Condition/Decision Coverage)，更是要多花不少心思。 全靠手工写，工作量太大，而且重复性工作不少。靠模糊测试命中的话效率又比较低。 那么，有没有什么办法可以将这些机械的工作做得自动化一点，机器能够帮我们设计一些测试用例呢？符号执行就是一种可用的利器。 什么是符号执行 为
klee, KLEE符号执行引擎.zip
09-18
klee, KLEE符号执行引擎 KLEE符号虚拟机 KLEE 是构建在LLVM编译器基础之上的一个符号虚拟机。 目前，主要有两个组件：核心符号虚拟机引擎；负责执行带有符号值支持的LLVM位码模块。 这由 lib/中的代码组成。面向支持of的posix/li
Convex_Symbolic:Python符号规范化程序和C代码生成器，用于嵌入凸优化问题
05-16
用于嵌入凸优化问题的Python符号规范化程序和C代码生成器。 它遵循与领先的Python凸面优化包相同的问题定义语法，函数命名和内部命名法。 例如，相同的受约束的最小二乘问题可以将其转换为C代码，如下所示： ...
deepstate:类似单元测试的接口，用于模糊测试和符号执行
05-13
深度状态 DeepState是一个框架，可为C和C ++开发人员提供指向各种符号执行和模糊处理引擎的通用接口。...但是却不知道要问什么 功能概述测试看起来像Google测试，但是可以使用符号执行/模糊化来生成数据（参数化
matlab.rar_matlab符号函数_symbolic matlab_symbolic toolbox
09-14
matlab利用符号工具箱进行解析函数求导演示的编程源码及示例图片
klee内存模型
qq_44370676的博客
02-28 622
klee内存模型
klee2.3 安装&&教程1-2
再走一步
01-01 1257
klee2.3 安装教程&&入门例子教程
符号执行初识
无痕的博客
11-02 921
符号执行介绍及原理阐述
介绍符号执行（symbolic execution）的概念，混合执行（concolic execution）的概念。
06-02
符号执行（Symbolic Execution）是一种自动化的程序分析技术，它可以对程序进行静态分析，探索程序的所有可能路径和输入组合，从而可以发现程序中的错误和漏洞。符号执行的核心思想是将程序的输入和状态都看作符号...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ziix

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

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

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

打赏作者

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

抵扣说明：

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

余额充值