毕设扫描器参数Fuzz数据的定义读取和装配(爬虫数据和Payload数据)

Posted pumpkin.zhu

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了毕设扫描器参数Fuzz数据的定义读取和装配(爬虫数据和Payload数据)相关的知识,希望对你有一定的参考价值。

文章目录

字典文件的数据结构

在项目根目录创建 fuzzDicts 目录,创建 fuzzDicts/params.json,用于测试参数。(使用 json 是因为常见/易读/复用性强)

参数测试Payload格式:不同的漏洞类型、漏洞类型下不同的软件系统、对应Payload。

一级数据是漏洞类型,如 SQLI、XSS等,数据结构是字典格式。(添加字段 description 描述payload,不需要专门使用一个字段进行分类。该部分是在读取 Json 文件时进行的修改)

二级数据是漏洞类型的下一级数据,可能需要根据不同软件类型选择 Payload,所以也要使用字典格式。二级数据如果不分软件类型,则定义键名为 universal(还要单独输入一个字段,而大多数情况都不知道软件类型,还是要枚举测试所有Payload,所以该字段不是很有必要)

二级数据是Payload,根据不同Payload需要选择不同的响应判断,如时间延迟注入的响应时间、响应内容中的关键字,所以使用字典格式。(Payload直接作为污染参数数据的键名即可)(实际读取 Json 文件时做出的优化)

一级数据是一个键 data,其键值是数据类型,用于存储 payload 的字典信息。

二级数据是最底层的数据,注入参数可能有很多、响应时间是整数、关键词是字符串等,所以根据实际需要分别使用 List、Int、String等数据类型。

未考虑的场景问题

  • 根据比较不同Payload下返回的响应信息来判断漏洞是否存在。

排版如下。


	"data":[
		"description": "SQLI-001: mysql-数字型延迟注入",
		"payload": "/**/and/**/sleep(5)",
		"time": 5,
		"keyword": ""
	,
	
		"description": "SQLI-002: MySQL-字符型延迟注入",
		"payload": "'/**/and/**/sleep(5)--+",
		"time": 5,
		"keyword": ""
	,
	
		"description": "SQLI-003: MySQL-字符型延迟注入",
		"payload": "\\"/**/and/**/sleep(5)--+",
		"time": 5,
		"keyword": ""
	,
	
		"description": "SQLI-004: MySQL-报错注入",
		"payload": "'\\"+,",
		"keyword": "You have an error in your SQL syntax"
	,
	
	
	
		"description": "XSS-001: 跨站脚本攻击漏洞"
		"payload": "<script>alert(/xss/)</script>",
		"keyword": "xxx"
	
	]
	

读取嵌套的 Json 数据

读取值为基本数据类型的Json文件

这里的单层是指,Json数据的值是基本数据类型,不是列表、字典等数据结构。

创建 test.json 文件,文件内容如下。


	"name": "pumpkin",
	"date": "2022-04-05"

查找网上文章 Go 对象序列化 等,编写读取Json文件代码。

  • 读取配置文件的字节数据:bytesJSON, err := ioutil.ReadFile(“example.json”)

  • go 内置对 json 数据的处理包是 encoding/json

  • 把字节数据解析成Json编码数据:json.Unmarshal

  • 接收Json数据:需要事先定义一个结构体

成功运行解析的代码和打印结果如下。

/* 打印结果
	pumpkin
	2022-04-05
*/

//定义配置文件解析后的结构
type Test struct 
	Name	string 	`json:"name"`
	Date	string `json:"date"`


func main() 

	var test Test

	bytes, err := ioutil.ReadFile("./test.json")
	if err != nil 
		fmt.Println("读取json文件失败", err)
		return
	

	err = json.Unmarshal(bytes, &test)
	if err != nil 
		fmt.Println("解析数据失败", err)
		return
	
	fmt.Println(test.Name)
	fmt.Println(test.Date)

读取值为数组的Json数据

test.json 配置文件的内容如下。

此时使用上一小节读取基本数据类型的代码,json.Unmarshal(bytes, &test) 会报错并退出程序,无法把数组结构解析成 Go 结构体的 string 类型:
解析数据失败 json: cannot unmarshal array into Go struct field Test.name of type string


	"name": ["pumpkin", "watermelon"],
	"date": "2022-04-05"

修改结构体的参数类型为字符串数组:[]string。运行成功且打印结果如下。

/*	打印结果
	[pumpkin watermelon]
	2022-04-05
*/
//定义配置文件解析后的结构
type Test struct 
	Name	[]string 	`json:"name"`
	Date	string 		`json:"date"`

读取值为字典的Json文件

参考文章 golang 数据三 (字典),golang基本数据结构Map也叫字典,字典的声明格式是:map[KeyType]ValueType

此时 test.json 配置文件的内容如下。


	"name": ["pumpkin", "watermelon"],
	"date": "2022-04-05"
	"sex":
		"man":1,
		"woman":0
	

定义接收 Json 数据的结构体如下,成功读取并打印 Json 数据内容。

//定义配置文件解析后的结构
type Test struct 
	Name	[]string 		`json:"name"`
	Date	string 			`json:"date"`
	Sex 	map[string]int	`json:"sex"`


// main()函数中的操作代码
func main() 
	var test Test

	bytes, err := ioutil.ReadFile("./test.json")
	if err != nil 
		fmt.Println("读取json文件失败", err)
		return
	

	err = json.Unmarshal(bytes, &test)
	if err != nil 
		fmt.Println("解析数据失败", err)
		return
	
		fmt.Println(test.Name)
		fmt.Println(test.Date)
		fmt.Println("man: ", test.Sex["man"])
		fmt.Println("woman: ", test.Sex["woman"])

读取包含两个层级键名的Json文件

此时 test.json 配置文件的内容如下。


	"req_list": [
		"url": "http://127.0.0.1/sqli-labs-master/Less-1/?id=1",
		"method": "GET",
		"headers": 
			"Spider-Name": "crawlergo",
			"User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (Khtml, like Gecko) Chrome/79.0.3945.0 Safari/537.36"
		,
		"data": "",
		"source": "Target"
	],

	"all_req_list": [
		"url": "http://127.0.0.1/sqli-labs-master/Less-1/?id=1",
		"method": "GET",
		"headers": 
			"Spider-Name": "crawlergo",
			"User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.0 Safari/537.36"
		,
		"data": "",
		"source": "Target"
	],

	"all_domain_list": ["127.0.0.1"],
	"sub_domain_list": ["127.0.0.1"]

尝试定义 req_list 的值为数组 array,json.Unmarshal() 函数报错:解析数据失败 json: cannot unmarshal object into Go struct field Crawler.req_list of type string。

type Crawler struct 
	ReqList         []string `json:"req_list"`
	AllReqList      []string `json:"all_req_list"`
	AllDomainList 	[]string `json:"all_domain_list"`
	SubDomainList 	[]string `json:"sub_domain_list"`

数组的元素值类型应该是字典 map,尝试定义如下结构体,仍然是相同的报错信息。

type Crawler struct 
	ReqList         []map[string]string `json:"req_list"`
	AllReqList      []map[string]string `json:"all_req_list"`
	AllDomainList 	[]map[string]string `json:"all_domain_list"`
	SubDomainList 	[]map[string]string `json:"sub_domain_list"`

由于 Json 文件包含不同层级的键名,所以定义结构体的结构也肯定不同,参考文章:Go 解析嵌套 json

如果 Json 数据有多层键,那么每层键都需要定义一个结构体接收对应的键名,并且定义变量时需要嵌套结构体类型。

查看参考文章编写代码,成功读取嵌套 Json 文件的代码和打印结果如下。

/*	打印结果
	http://127.0.0.1/sqli-labs-master/Less-1/?id=1
	GET

	Spider-Name crawlergo
	User-Agent Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.0 Safari/537.36
*/
// 接收第一层 Json 数据
type CrawlerFirst struct 
	ReqList			[]CrawlerSecond			`json:"req_list"`
	AllReqList      []CrawlerSecond 		`json:"all_req_list"`
	AllDomainList 	[]string 				`json:"all_domain_list"`
	SubDomainList 	[]string 				`json:"sub_domain_list"`



type CrawlerSecond struct 
	Url			string						`json:"url"`
	Method      string 						`json:"method"`
	Headers 	map[string]string 			`json:"headers"`
	Data 		string 						`json:"data"`
	Source 		string						`json:"source"`



// Test 定义配置文件解析后的结构
type Test struct 
	Name	[]string 		`json:"name"`
	Date	string 			`json:"date"`
	Sex 	map[string]int	`json:"sex"`


func main() 

	//var req model.Request

	var crawlerFirst CrawlerFirst

	bytes, err := ioutil.ReadFile("./debug.json")
	if err != nil 
		fmt.Println("读取json文件失败", err)
		return
	

	err = json.Unmarshal(bytes, &crawlerFirst)
	if err != nil 
		fmt.Println("解析数据失败", err)
		return
	

	for _,req:= range crawlerFirst.ReqList


		fmt.Println(req.Url)
		fmt.Println(req.Method)
		fmt.Println(req.Data)

		for key,value:= range req.Headers 

			fmt.Println(key, value)

		
	


准备数据阶段

修改爬虫保存结果(结合报错和实际情况未修改代码,可忽略)

读取爬虫结果的前提是,爬虫结果是我们需要的数据。原项目中把如下 4 种数据保存到一个 Json 文件,我们首先需要分离这些数据,使每种数据分别保存到各自的文件。

type Result struct 
	ReqList       []Request `json:"req_list"`
	AllReqList    []Request `json:"all_req_list"`
	AllDomainList []string  `json:"all_domain_list"`
	SubDomainList []string  `json:"sub_domain_list"`

crawlergo_cmd.go 文件保存结果的相关代码,调试打印 result 变量值发现,此时爬虫结果按照 Result 结构体都已经填充内容。先酱紫,后续对爬虫结果结构体有想法,再另外进行修改。

考虑到报错、以及直接可以读取 Json 文件,不修改代码。

	// 代码 350 行
	// 输出结果
	outputResult(result)

// 代码 403 行
func outputResult(result *pkg.Result) 
	// 输出结果
	if outputMode == "json" 
		fmt.Println("--[Mission Complete]--")
		resBytes := getJsonSerialize(result)
		fmt.Println(string(resBytes))
	 else if outputMode == "console" 
		for _, req := range result.ReqList 
			req.FormatPrint()
		
	

	// 写入文件的主要代码
	if len(outputJsonPath) != 0 
		resBytes := getJsonSerialize(result)
		tools.WriteFile(outputJsonPath, resBytes)
	

	// 修改该部分主要代码为如下内容(不更改代码,直接读取 json 文件)
	/*
		注意,
		1.结构体中的变量名需要开启调试查看、或从其他代码中找到
		2.序列化结构体的变量时,报错如下。
		在结构体定义代码中,前两个变量的类型是 []Request,域名变量是 []string
		
		考虑到可以直接读取Json文件,不更改代码。
		cannot use result.ReqList (type []*model.Request) as type *pkg.Result in argument to getJsonSerialize
		cannot use result.AllDomainList (type []string) as type *pkg.Result in argument to getJsonSerialize
	*/
	if len(outputJsonPath) != 0 
		resBytes1 := getJsonSerialize(result.req_list)
		resBytes2 := getJsonSerialize(result.all_req_list)
		resBytes3 := getJsonSerialize(result.all_domain_list)
		resBytes4 := getJsonSerialize(result.sub_domain_list)
		tools.WriteFile("req_" + outputJsonPath, resBytes1)
		tools.WriteFile("all_req_" + outputJsonPath, resBytes2)
		tools.WriteFile("all_domain_" + outputJsonPath, resBytes3)
		tools.WriteFile("sub_domain_" + outputJsonPath, resBytes4)
	
	

从 Json 文件读取需要的爬虫数据

关于嵌套 Json 文件数据的读取,在本文的上一章节《读取嵌套的 Json 数据》已完成了代码的编写和调试。

读取数据的任务完成了,Fuzz 需要用到哪些数据呢?

url
method
headers	// 为了避免被反爬虫限制访问,必须使用合适的请求头
data

读取爬虫Json文件

// 接收第一层 Json 数据
type CrawlerFirst struct 
	ReqList			[]CrawlerSecond			`json:"req_list"`
	AllReqList      []CrawlerSecond 		`json:"all_req_list"`
	AllDomainList 	[]string 				`json:"all_domain_list"`
	SubDomainList 	[]string 				`json:"sub_domain_list"`



type CrawlerSecond struct 
	Url			string						`json:"url"`
	Method      string 						`json:"method"`
	Headers 	map[string]string 			`json:"headers"`
	Data 		string 						`json:"data"`
	Source 		string						`json:"source"`


// 封装函数
func read_crawler() CrawlerFirst
	var crawlerFirst CrawlerFirst

	bytes, err := ioutil.ReadFile("./debug.json")
	if err != nil 
		fmt.Println("读取json文件失败", err)
		os.Exit(1)
	

	err = json.Unmarshal(bytes, &crawlerFirst)
	if err != nil 
		fmt.Println("解析数据失败", err)
		os.Exit(1)
	

	return crawlerFirst


读取 paramsFuzz.json 文件

读取代码改了又改,总是报错。无奈从基本数据类型开始编写 Json 文件进行读取,然后逐渐嵌套数据并完成读取 Json 数据,最终代码和打印结果如下。

读取的 Json 文件见本文第一章 字典文件的数据结构

/* 打印 sqli 键值的结果
//	/**/and/**/sleep(5)
//	MySQL-数字型延迟注入
//	5
	
//	'/**/and/**/sleep(5)--+
//	MySQL-字符型延迟注入
//	5
	
//	"/**/and/**/sleep(5)--+
//	MySQL-字符型延迟注入
//	5
	
//	'"+,
//	MySQL-报错注入
//	0
//	You have an error in your SQL syntax
*/

// 定义配置文件解析后的结构
type ParamsFuzzJson struct 
	SqlInjection	[]ParamData		`json:"sqli"`
	Xss				[]ParamData		`json:"xss"`


type ParamData struct 
	Payload 	string		`json:"payload"`
	Description string 		`json:"description"`
	Time 		int			`json:"time"`
	Keyword		string		`json:"keyword"`


func main() 

	//var req model.Request

	var paramsFuzzJson ParamsFuzzJson

	bytes, err := ioutil.ReadFile("./fuzzDicts/paramsFuzz.json")

	if err != nil 
		fmt.Println("读取json文件失败", err)
		// os.Exit(1)
		return
	

	err = json.Unmarshal(bytes, &paramsFuzzJson)
	if err != nil 
		fmt.Println("解析数据失败", err)
		return
		//os.Exit(1)
	
	
	// fmt.Println(paramsFuzzJson.SqlInjection)

	// 读取 Json 的 sqli 键
	for _, param:= range paramsFuzzJson.SqlInjection
		// for _,param:= range param.key
		fmt.Println(param.Payload)
		fmt.Println(param.Description)
		fmt.Println(param.Time)
		fmt.Println(param.Keyword)

	
	



装配数据阶段

配置请求对象 req

项目文件 crawlergo/pkg/model 定义的请求对象结构体包含 8 个变量,考虑只保留如下 5 个变量,重新在 paramsFuzz.go 文件定义请求对象结构体。

type Request struct 
	URL             *URL
	Method          string
	Headers         map[string]interface
	PostData        string
	Proxy           string

明确参数 Fuzz 的需求

  • 遍历 req_list:爬虫结果中 req_list 键的内容,如果存在Get参数或Post参数则进行 Fuzz
  • 遍历 paramJson 中的每一个键:sqli、xss等

保存传递动态参数的 Url 信息

对于爬虫结果,要筛选出传递动态参数的URl进行参数Fuzz测试。

顺便把传递动态参数的Url保存到新的Json文件,方便人工查看,如下代码把传递动态参数的爬虫结果保存到指定文件 params_debug.json。

// 接收第一层 Json 数据
type CrawlerJson struct 
	ReqList			[]CrawlerData			`json:"req_list"`
	AllReqList      []CrawlerData 		`json:"all_req_list"`
	AllDomainList 	[]string 				`json:"all_domain_list"`
	SubDomainList 	[]string 				`json:"sub_domain_list"`


type CrawlerData struct 
	Url			string						`json:"url"`
	Method      string 						`json:"method"`
	Headers 	map[string]string 			`json:"headers"`
	Data 		string 						`json:"data"`
	Source 		string						`json:"source"`


// 调用代码
for _,crawler:= range crawlerReq 
	outputParamsResult(crawler)


func outputParamsResult(result CrawlerData) 

	// 写入的文件名变量,在合并代码时需要调整修改
	outputJsonPath := "debug.json"

	// 输出结果
	if len(outputJsonPath) != 0 
		resBytes := getParamsJsonSerialize(result)
		tools.WriteFile("params_" + outputJsonPath, resBytes)
	



func getParamsJsonSerialize(paramsResult CrawlerData) []byte 

	resBytes, err := json.Marshal(paramsResult)
	if err != nil 
		log.Fatal("Marshal result error")
	
	return resBytes

装配数据

算法步骤:

  • 准备数据1:读取爬虫结果,调用爬虫结构体的参数信息
  • 准备数据2:读取参数 Fuzz 字典,调用结构体
  • 筛选:遍历爬虫结构体,通过条件判断找出传递动态参数的Url,根据传参方式分为 Get 和 Post
  • 准备数据3:逐个添加 Payload 到动态参数末尾,如果是 Get 方式则拼接 Url 和参数
  • 装配:把爬虫结构体的信息、以及处理后的动态参数信息,装配到请求对象 req
  • 运行和验证:发送请求,查看响应信息验证漏洞是否存在(运行阶段)
  • 标记去重:如果动态参数测试过了,则加入 Array ,并且在测试动态参数前检查是否在 Array 中(验证阶段)
第一步

读取爬虫结果

// 接收第一层 Json 数据
type CrawlerJson struct 
	ReqList			[]CrawlerData			`json:"req_list"`
	AllReqList      []CrawlerData 		`json:"all_req_list"`
	AllDomainList 	[]string 				`json:"all_domain_list"`
	SubDomainList 	[]string 				`json:"sub_domain_list"`


type CrawlerData struct 
	Url			string						`json:"url"`
	Method      string 						`json:"method"`
	Headers 	map[string]string 			`json:"headers"`
	Data 		string 						`json:"data"`
	Source 		string						`json:"source"`


func main() 
	// 1.读取爬虫结果
	crawlerReq := read_crawlerReq()



func read_crawlerReq() [毕设扫描器参数Fuzz第二篇:动态爬虫的创建启动和协程池

毕设扫描器动态爬虫CrawlerGo源码分析1:cli库的使用

毕设扫描器动态爬虫CrawlerGo源码分析1:主文件cli库的使用

毕设扫描器动态爬虫CrawlerGo直观使用效果分析

毕设扫描器动态爬虫CrawlerGo直观使用效果分析

Web漏洞扫描这件事爬虫