1、介绍
四种爆破模式
(1)sniper
- 样本中可以设置一个或多个待测参数点，记为x={x1,x2,..xn}
- 只需要设置一个payload集合，记为y={y1,y2,...ym}
- 测试过程是从唯一的payload集合中，逐个取出，对参数点x1替换。然后依次对参数点x2,..xn替换。
- 总的测试请求个数是n*m
(2)battering_ram
- 样本中可以设置一个或多个待测参数点，记为x={x1,x2,..xn}
- 只需要设置一个payload集合，记为y={y1,y2,...ym}
- 测试过程是从唯一的payload集合中，逐个取出，对参数点x1,x2...xn同时替换。
- 总的测试请求个数是m
(3)pitchfork
- 样本中可以设置一个或多个待测参数点，记为x={x1,x2,..xn}
- 需要设置对应待测参数点个数的，即n个payload集合，记为y={y1,y2,..yn}，此时y1表示一个payload集合。这些集合内各自的payload个数分别记为m1,m2,..mn，可能是不等的，记m_min为最小长度
- 测试过程是同时从y1,y2...yn中取出相同索引的payload，对参数点x1,x2...xn分别同时替换。索引从0到m_min递增，逐次操作。
- 总的测试请求个数是m_min
(4)cluster_bomb
- 样本中可以设置一个或多个待测参数点，记为x={x1,x2,..xn}
- 需要设置对应待测参数点个数的，即n个payload集合，记为y={y1,y2,..yn}，此时y1表示一个payload集合。这些集合内各自的payload个数分别记为m1,m2,..mn，可能是不等的
- 测试过程是完全交叉组合，由各个payload集合每次各自取出一个payload，遍历所有情况。
- 具体来说，通过进制算法进行实现：
- 假设一个n位的数，对应n个集合和n个待测参数点
- 初始时，各位上为0
- 各位上允许的最大数为对应(m1-1),(m2-1)...(mn-1)
- 设定左侧为低位，右侧为高位
- 循环操作：
- 每次是最低位+1
- 然后从低位到高位逐位判断，是否超出各位上允许的最大数。如果超出，则当前位设为0，下一位+1。这样依次判断到次高位
- 最高位单独判断，如果其超出位上允许的最大数，则结束循环操作
- 如果最高位未溢出，则本次+1是合法的，取出各位上的值，作为各集合的索引取出payload，分别替换各参数点
- 实际的循环操作，是从各位都是0开始，因此是先默认合法，直接取出payload替换，然后再+1进行判断是否溢出
- 进制算法需要注意是需要提前检查各位上允许的最大数不能是0，即m1,m2..mn都不能是0，或者说设置的各payload集合不能存在为空
- 总的测试请求个数是m1*m2*..*mn
2、代码
"""
sniper模式
样本中可以设置一个或多个待测参数点，记为x={x1,x2,..xn}
只需要设置一个payload集合，记为y={y1,y2,...ym}
测试过程是从唯一的payload集合中，逐个取出，对参数点x1替换。然后依次对参数点x2,..xn替换。
总的测试请求个数是n*m
"""
from api import RadixModule
def sniper(s: str, index_list: list[int], payload_list_list: list[list[str]]):
result = list()
payload_list = payload_list_list[0]
if s != '' and len(index_list) > 0 and len(index_list) % 2 == 0:
for i in range(int(len(index_list) / 2)):
for j in range(len(payload_list)):
last_index = 0
string = ''
for k in range(int(len(index_list) / 2)):
string = string + s[last_index: index_list[2 * k]]
last_index = index_list[2 * k]
if i == k:
string = string + payload_list[j]
else:
string = string + s[last_index: index_list[2 * k + 1]]
last_index = index_list[2 * k + 1]
else:
string = string + s[last_index:]
result.append(string)
return result
"""
battering_ram模式
样本中可以设置一个或多个待测参数点，记为x={x1,x2,..xn}
只需要设置一个payload集合，记为y={y1,y2,...ym}
测试过程是从唯一的payload集合中，逐个取出，对参数点x1,x2...xn同时替换。
总的测试请求个数是m
"""
def battering_ram(s: str, index_list: list[int], payload_list_list: list[list[str]]):
result = list()
payload_list = payload_list_list[0]
if s != '' and len(index_list) > 0 and len(index_list) % 2 == 0:
for j in range(len(payload_list)):
last_index = 0
string = ''
for k in range(int(len(index_list) / 2)):
string = string + s[last_index: index_list[2 * k]]
string = string + payload_list[j]
last_index = index_list[2 * k + 1]
else:
string = string + s[last_index:]
result.append(string)
return result
"""
pitchfork模式
样本中可以设置一个或多个待测参数点，记为x={x1,x2,..xn}
需要设置对应待测参数点个数的，即n个payload集合，记为y={y1,y2,..yn}，此时y1表示一个payload集合。这些集合内各自的payload个数分别记为m1,m2,..mn，可能是不等的，记m_min为最小长度
测试过程是同时从y1,y2...yn中取出相同索引的payload，对参数点x1,x2...xn分别同时替换。索引从0到m_min递增，逐次操作。
总的测试请求个数是m_min
"""
def pitchfork(s: str, index_list: list[int], payload_list_list: list[list[str]]):
result = list()
# 获取最小长度的payload_list
min_len = len(payload_list_list[0])
for i in range(1, len(payload_list_list)):
if len(payload_list_list[i]) < min_len:
min_len = len(payload_list_list[i])
if s != '' and len(index_list) > 0 and len(index_list) % 2 == 0:
for j in range(min_len):
last_index = 0
string = ''
for k in range(int(len(index_list) / 2)):
string = string + s[last_index: index_list[2 * k]]
string = string + payload_list_list[k][j]
last_index = index_list[2 * k + 1]
else:
string = string + s[last_index:]
result.append(string)
return result
"""
cluster_bomb模式
样本中可以设置一个或多个待测参数点，记为x={x1,x2,..xn}
需要设置对应待测参数点个数的，即n个payload集合，记为y={y1,y2,..yn}，此时y1表示一个payload集合。这些集合内各自的payload个数分别记为m1,m2,..mn，可能是不等的
测试过程是完全交叉组合，由各个payload集合每次各自取出一个payload，遍历所有情况。
具体来说，通过进制算法进行实现：
假设一个n位的数，对应n个集合和n个待测参数点
初始时，各位上为0
各位上允许的最大数为对应(m1-1),(m2-1)...(mn-1)
设定左侧为低位，右侧为高位
循环操作：
每次是最低位+1
然后从低位到高位逐位判断，是否超出各位上允许的最大数。如果超出，则当前位设为0，下一位+1。这样依次判断到次高位
最高位单独判断，如果其超出位上允许的最大数，则结束循环操作
如果最高位未溢出，则本次+1是合法的，取出各位上的值，作为各集合的索引取出payload，分别替换各参数点
实际的循环操作，是从各位都是0开始，因此是先默认合法，直接取出payload替换，然后再+1进行判断是否溢出
进制算法需要注意是需要提前检查各位上允许的最大数不能是0，即m1,m2..mn都不能是0，或者说设置的各payload集合不能存在为空
总的测试请求个数是m1*m2*..*mn
"""
def cluster_bomb(s: str, index_list: list[int], payload_list_list: list[list[str]]):
# 返回结果，list[str]
result = list()
# 进制算法，获取索引组合的list
list_len_list = list()
for i in range(len(payload_list_list)):
list_len_list.append(len(payload_list_list[i]))
index_list_list: list[list[int]] = RadixModule.radix_by_plural_list(list_len_list=list_len_list,
low_in_left_flag=True)
# 根据进制算法结果，替换payload
for i in range(len(index_list_list)):
# 样本切割后的元素遍历，逐个拼接
string = ''
last_index = 0
for j in range(int(len(index_list)/2)):
string = string + s[last_index: index_list[j*2]]
string = string + payload_list_list[j][index_list_list[i][j]]
last_index = index_list[2*j + 1]
else:
string = string + s[last_index:]
result.append(string)
return result
def blast(mode: int, s: str, index_list: list[int], payload_list_list: list[list[str]]):
if mode == 0:
return sniper(s=s, index_list=index_list, payload_list_list=payload_list_list)
elif mode == 1:
return battering_ram(s=s, index_list=index_list, payload_list_list=payload_list_list)
elif mode == 2:
return pitchfork(s=s, index_list=index_list, payload_list_list=payload_list_list)
elif mode == 3:
return cluster_bomb(s=s, index_list=index_list, payload_list_list=payload_list_list)
if __name__ == '__main__':
# 测试
data = cluster_bomb('abcdefg', index_list=[1, 3, 4, 5], payload_list_list=[['abc', '000'], ['zzz', '111']])
print(data)