[刺客伍六七&黑客] 魔刀千刃evilblade的使用手册与开源
0x00 前言
2023.8.15 夜里
非常欢迎使用我的魔刀千刃，并且欢迎各位师傅对我的开源代码进行指导！
—–Offense without defense,
unparalleled in the world.—–
Welcome to the universe of N1nEmAn.
To find detailed usage instructions for evilblade,
please visit cnblogs.com/9man.
访问连接：https://pypi.org/project/evilblade/
0x01 安装
安装直接如下命令。
pip3 install evilblade
本包还依赖包LibcSearcher和pwntools，如未安装，请安装。
pip3 install pwntools
pip3 install LibcSearcher
0x02 内置帮助
为了兼容问题内置帮助我没有写中文，在这里写中文版本的。
内置帮助命令：python -m pydoc evilblade，按q退出。
0x03 中文帮助
dp(name, data)
# 数据打印
dpx(name, data)
# 数据以十六进制格式打印
evgdb(*argv)
# 设置 gdb，也称为 evil-gdb
# 如果需要设置断点，请将 'b address/defname' 作为参数。
fmt(offset, begin, end, size, written)
# 用于格式化字符串漏洞，但实用性不高。
getbase(add, defname, *args)
# 计算 libc 的基地址。"add" 是泄露的地址，"defname" 是库函数名，"*args" 是需要减去的额外偏移量。
getd(i, j)
# 用于十进制格式
# 类似于 getx32
getx(i, j)
# 用于十六进制格式
# 类似于 getx32
getx32(i, j)
# 用于 32 位
# 在使用 tet() 测试过的 '\xff' 格式之后，你可以接收地址。
# "i" 参数表示接收数据的开头，"j" 表示结尾。
# 通常 "i" 设置为 0，"j" 设置为 -1。
# 不断修改 "i" 和 "j" 的值，直到获得满意的结果为止。
getx64(i, j)
# 用于 64 位
# 类似于 getx32
gotadd(defname, *args)
# 没有 PIE 保护，如果参数只有 "defname"，得到 GOT 表地址。
# 有 PIE 保护，如果参数只有 "defname"，得到 GOT 表地址偏移。加上第二个参数作为基地址，得到实际 GOT 表地址。
ia lambda (...)
# 启动交互式 shell
libset(libc_val)
# 设置你的 libc，也称为 libc-set
n2b lambda x
# 将数字转换为字节
pltadd(defname, *args)
# 类似于 gotadd，但获取的是 PLT 表的地址
rgetbase(add, defname, *args)
# 类似于 'getbase'，但用于远程 libc 库
rl lambda (...)
# 接收一行数据，相当于 p.recvline()
rlibset(defname, add)
# 设置远程 libc 库。
rop lambda r
# 将值列表转换为 ROP 链（64 位）
rsetup(mip, mport)
# 建立远程连接
rsymoff(defname, *args)
# 类似于 'symoff'，但用于远程 libc 库
ru lambda s
# 接收数据，直到特定字符串，相当于 p.recvuntil(s)
rv lambda x
# 接收数据，相当于 p.recv(x)
sa lambda t, s
# 在特定字符串后发送数据，相当于 p.sendafter(t, s)
sd lambda s
# 发送数据，相当于 p.send(s)
setup(p_val)
# 设置你的进程和 ELF
sl lambda s
# 发送带有 '\n' 的数据，相当于 p.sendline(s)
sla lambda t, s
# 在特定字符串后发送一行数据，相当于 p.sendlineafter(t, s)
sn lambda n
# 发送一个带有 '\n' 的数字，相当于 sl(n2b(n))
sna lambda t, n
# 在特定字符串后发送一个数字，相当于 sla(t, n2b(n))
symadd(defname, *args)
# 类似于 gotadd，但获取的是 SYM 表的地址
symoff(defname, *args)
# 如果参数只有 'defname'，你会得到偏移量。
# 如果有第二个参数作为基地址，你会得到函数的实际地址。
terset(get)
# 如果你不能直接运行 GDB，请根据情况使用 'terset' 来设置终端。使用 'echo $TERM' 的输出作为参数。
tet()
# 接收一行数据，并将其显示给你
uu64 lambda data
# 从字节中解包一个 64 位无符号整数
0x02 开源代码
from pwn import *
from LibcSearcher import *
'''
明知道是陷阱，
为什么还要来。
'''
# Convert a number to bytes
n2b = lambda x: str(x).encode()
# Receive data, equivalent to p.recv(x)
rv = lambda x: p.recv(x)
# Receive a line of data, equivalent to p.recvline()
rl = lambda: p.recvline()
# Receive data until a specific string, equivalent to p.recvuntil(s)
ru = lambda s: p.recvuntil(s)
# Send data, equivalent to p.send(s)
sd = lambda s: p.send(s)
# Send data with '\n', equivalent to p.sendline(s)
sl = lambda s: p.sendline(s)
# Send a number with '\n', equivalent to sl(n2b(n))
sn = lambda n: sl(n2b(n))
# Send data after a specific string, equivalent to p.sendafter(t, s)
sa = lambda t, s: p.sendafter(t, s)
# Send a line of data after a specific string, equivalent to p.sendlineafter(t, s)
sla = lambda t, s: p.sendlineafter(t, s)
# Send a number after a specific string, equivalent to sla(t,n2b(n))
sna = lambda t, n: sla(t, n2b(n))
# Start an interactive shell
ia = lambda: p.interactive()
# Convert a list of values to a ROP chain (64-bit)
rop = lambda r: flat([p64(x) for x in r])
# Unpack a 64-bit unsigned integer from bytes
uu64 = lambda data: u64(data.ljust(8, b'\x00'))
##Set your libc, aka libc-set
def libset(libc_val):
global libc
libc = ELF(libc_val)
#Set your prosecc and ELF
def setup(p_val):
global p
global elf
p = process(p_val)
elf = ELF(p_val)
#Establish remote connection
def rsetup(mip, mport):#设置远程连接 remote setup
if args.P:
global p
p = remote(mip,mport)
##Recieve a line of data, and show it for you
def tet():
#test,测试接收数据
p = globals()['p']
r = ru('\n')
print('\n----------------\n','add','is >>> ',r,'\n---------------')
return r
#For 64-bit
#Just like getx32
def getx64(i,j):
if i != 0:
r = (ru('\n'))[i:j]
dp('getx64',r)
r = u64(r.ljust(8,b'\0'))
print('\n----------------\n','add','is >>> ',hex(r),'\n---------------')
return r
else:
r = (ru('\n'))[:j]
dp('getx64',r)
r = u64(r.ljust(8,b'\0'))
print('\n----------------\n','add','is >>> ',hex(r),'\n---------------')
return r
#For 32-bit
#After testing with tet(), addresses can be received for the '\xff' format.
#The 'i' parameter represents the start of the received data, while 'j' indicates the end.
#Usually, 'i' is set to 0, and 'j' is set to -1.
#Continuously adjust the values of 'i' and 'j' until you obtain the desired result.
def getx32(i,j):
if i != 0:
r = (ru('\n'))[i:j]
dp('getx32',r)
r = u32(r.ljust(4,b'\0'))
print('\n----------------\n','add','is >>> ',hex(r),'\n---------------')
return r
else:
r = (ru('\n'))[:j]
dp('getx32',r)
r = u32(r.ljust(4,b'\0'))
print('\n----------------\n','add','is >>> ',hex(r),'\n---------------')
return r
#For the hex format
#Just like getx32
def getx(i,j):
if i != 0:
r = (ru('\n'))[i:j]
dp('geti',r)
r = int(r,16)
print('\n----------------\n','add','is >>> ',hex(r),'\n---------------')
return r
else:
r = (ru('\n'))[:j]
dp('geti',r)
r = int(r,16)
print('\n----------------\n','add','is >>> ',hex(r),'\n---------------')
return r
#For the decimal format
#Just like getx32
def getd(i,j):
if i != 0:
r = (ru('\n'))[i:j]
dp('geti',r)
r = int(r,10)
print('\n----------------\n','add','is >>> ',hex(r),'\n---------------')
return r
else:
r = (ru('\n'))[:j]
dp('geti',r)
r = int(r,10)
print('\n----------------\n','add','is >>> ',hex(r),'\n---------------')
return r
'''
只攻不防，
天下无双—————
魔刀千刃。
'''
##计算世界
#Calculate the base address of libc. "add" is the leaked address, "defname" is the library function name, and "*args" are the excess offsets that need to be subtracted.
def getbase(add,defname,*args):
#计算libcbase，args作为多余参数相减 get libcbase
base = add - libc.sym[defname]
for num in args:
base -= num
print('\nloading...')
print('\n----------------\nget!your base is >>> ',hex(base),'\n--------------')
return base
ter = 'NULL'
#If you are unable to directly run GDB, please use the 'terset' to set the terminal according to your situation. Use the output of 'echo $TERM' as the parameter.
def terset(get):
global ter
dp('ter',ter)
#Set gdb,aka evil-gdb
#If you need to set a breakpoint, please use 'b address/defname' as the parameter.
def evgdb(*argv):
p = globals()['p']
ter = globals()['ter']
#获取全局变量值
dp('gdbter',ter)
if ter!='NULL':
context.terminal = [ter, '-e']
if args.G:
if(len(argv)==0):
gdb.attach(p)
else:
gdb.attach(p,argv[0])
#If the parameter is only 'defname', you will get the offset.
#If there's a second parameter as the base address, you will get the actual address of the function.
def symoff(defname,*args):#计算或者设置偏移symbol's offset
if(len(args)>0):
ba = args[0]
print('\n----------------\nyour ',defname,'offset is >>> ',hex(libc.sym[defname]),'\n---------------')
print('\n----------------\nyour ',defname,'is in >>> ',hex(ba+libc.sym[defname]),'\n---------------')
return libc.sym[defname]+ba
else:
print('\n---------------\nyour ',defname,'offset is >>> ',hex(libc.sym[defname]),'\n---------------')
return libc.sym[defname]
#Without PIE, if only "defname", obtain the address of the GOT table.
#With PIE, if only "defname", obtain the offset of the GOT table. Adding the second parameter as the base address will give you the actual GOT table address.
def gotadd(defname,*args):#获取got表地址got'sadd
if (len(args) > 0):
return elf.got[defname]+args[0]#有pie的时候
return elf.got[defname]
#Jusr like gotadd,but obtain the address of the PLT table
def pltadd(defname,*args):#获取got表地址got'sadd
if (len(args) > 0):
return elf.plt[defname]+args[0]#有pie的时候
return elf.plt[defname]
#Just like gotadd,but obtain the address of the SYM table
def symadd(defname,*args):#获取got表地址got'sadd
if (len(args) > 0):
return elf.sym[defname]+args[0]#有pie的时候
return elf.sym[defname]
#Data print
def dp(name,data):#打印数值data print
print('\n---------------\nyour ',name,' is >>> ',(data),'\n---------------')
#Data print as hex
def dpx(name,data):#hex打印数值data print
print('\n---------------\nyour ',name,' is >>> ',hex(data),'\n---------------')
'''
因为，
我有想要保护的人。
'''
##查库世界
#Set the remote libc library.
def rlibset(defname,add):
#远程libc设置
global rlibc
rlibc = LibcSearcher(defname, add)
#Just like 'getbase', but for remote libc library
def rgetbase(add,defname,*args):
#计算远程libcbase，args作为多余参数相减 get libcbase
base = add - rlibc.dump(defname)
for num in args:
base -= num
print('\nloading...')
print('\n----------------\nget!your base is >>> ',hex(base),'\n--------------')
return base
#Just like 'symoff',but for remote libc library
def rsymoff(defname,*args):#计算或者设置偏移symblol's offset
if(len(args)>0):
ba = args[0]
print('\n----------------\nyour ',defname,'offset is >>> ',hex(rlibc.dump(defname)),'\n---------------')
print('\n----------------\nyour ',defname,'is in >>> ',hex(ba+rlibc.dump(defname)),'\n---------------')
return rlibc.dump(defname)+ba
else:
print('\n---------------\nyour ',defname,'offset is >>> ',hex(rlibc.dump(defname)),'\n---------------')
return rlibc.dump(defname)
#攻击世界
#For fmt, but the reliability is not high.
def fmt(offset,begin,end,size,written):
#fmt利用
payload = fmtstr_payload(offset,{begin: end},write_size = size,numbwritten=written)
return payload
'''
offset（int） - 您控制的第一个格式化程序的偏移量
字典（dict） - 被写入地址对应->写入的数据，可多个对应{addr: value, addr2: value2}
numbwritten（int） - printf函数已写入的字节数
write_size（str） - 必须是byte，short或int。告诉您是否要逐字节写入，短按short或int（hhn，hn或n）
'''
