<think>我们面对的是一个CTF题目，名为[
HCTF 2018]Warm
Up 1。根据引用内容，我们得知题目涉及Web安全，特别是文件包含漏洞的利用。
题目提供了一个入口，通常是一个网页，其中包含一个文件包含的功能点。根据引用[
1]，我们得知：
1. 题目提示flag在文件ffffllllaaaagggg中。
2. 尝试通过构造URL来包含这个文件，例如：http://.../source.
php?file=source.
php?../ffffllllaaaagggg
3. 需要不断添加`../`来尝试进入根目录，因为文件可能位于根目录下。最终成功访问的URL是：http://.../source.
php?file=source.
php?/../../../../../../../../ffffllllaaaagggg
引用[2]提供了更详细的分析：
1. 参数构造应该是：?source.
php?../../../../flag.txt 但是这里有一个截断判断。
2. 代码对参数进行了两次处理，第一次判断为false，第二次为true，因此需要绕过。
3. 最终构造的URL参数是：?source.
php%253f../../../../flag.txt （注意%253f是?的两次URL编码）
但是，我们注意到题目中实际使用的文件名是`ffffllllaaaagggg`，而不是`flag.txt`。
解题思路：
1. 题目提供了一个文件包含的接口，通过`source.
php`的`file`参数来包含文件。
2. 尝试包含`hint.
php`文件（根据引用[
1]中提示进入hint.
php），我们得知flag在`ffffllllaaaagggg`文件中。
3. 由于文件路径可能不在当前目录，我们需要使用目录遍历（`../`）来跳转到根目录。
4. 但是，题目中可能对包含的文件名进行了过滤，比如不允许直接包含`ffffllllaaaagggg`，或者对路径进行了限制。
根据引用[2]的分析，代码中可能进行了两次检查，并且有一次URL解码。因此，我们需要对参数进行编码绕过。
步骤：
1. 访问`source.
php`文件，查看源代码，通常CTF题目会给出源代码或者提示。
2. 根据引用[
1]，我们可以直接访问`source.
php?file=source.
php`来查看源代码（因为题目提示了`source.
php?file=source.
php`）。
3. 分析源代码，确定过滤规则。
4. 构造包含路径。
由于我们没有实际的源代码，但根据引用[2]的分析，我们可以尝试以下步骤：
尝试
1：直接包含
URL: http://target/source.
php?file=ffffllllaaaagggg
可能失败，因为文件不在当前目录。
尝试2：使用相对路径
URL: http://target/source.
php?file=../../../../ffffllllaaaagggg
但可能被过滤，因为`../`可能被检测。
尝试3：绕过过滤
根据引用[2]，我们可以尝试对特殊字符进行编码。例如，将`?`编码为`%253f`（因为`?`的URL编码是`%3f`，再编码一次就是`%253f`），这样在服务器端第一次解码得到`%3f`，第二次解码得到`?`，从而绕过检查。
构造URL: http://target/source.
php?file=source.
php%253f../../../../ffffllllaaaagggg
或者：http://target/source.
php?file=source.
php%253f../../../../../../../ffffllllaaaagggg
注意：这里使用了`source.
php?`，但实际上我们是要包含`ffffllllaaaagggg`文件。为什么这样构造？
引用[2]中解释：代码可能首先检查文件名是否在白名单中（比如`source.
php`、`hint.
php`等），然后通过截断或解码来包含其他文件。
具体来说，代码逻辑可能是这样的：
- 首先，获取`file`参数，假设为`source.
php?../../../../ffffllllaaaagggg`
- 然后，检查文件名部分（第一个`?`之前的部分）是否是白名单内的文件（如`source.
php`），如果是则允许包含。
- 但是，由于有两次URL解码，所以我们需要将第一个`?`编码两次，这样在第一次检查时（第一次解码后）还是`%3f`，不会被当作参数分隔符，因此文件名部分还是`source.
php`，通过检查。然后第二次解码将`%3f`变成`?`，从而将后面的部分当作路径。
因此，我们构造的`file`参数值为：`source.
php%253f../../../../ffffllllaaaagggg`
服务器第一次解码（可能是自动的）得到：`source.
php%3f../../../../ffffllllaaaagggg`
然后代码可能再进行一次解码（或者检查时又进行了一次解码）得到：`source.
php?../../../../ffffllllaaaagggg`
这样，在检查时，它认为我们要包含的是`source.
php`（因为检查时可能只取第一个`?`之前的内容），所以通过检查，然后实际包含的是整个字符串，而`source.
php?`后面的部分被当作路径，这样就实现了路径穿越。
但是，我们也可以尝试直接使用多个`../`来达到根目录，因为题目中提示需要不断添加`../`直到成功。
尝试4：直接使用多次`../`（根据引用[
1]）
URL: http://target/source.
php?file=source.
php?/../../../../../../../../ffffllllaaaagggg
注意：这里在`source.
php`后面直接跟了一个`?`，然后就是多个`../`。这样构造的原因可能是为了利用代码中的检查逻辑。
总结：
根据两种引用，我们有两种可能的构造方式：
A. 使用多次`../`（8次）并且直接使用`?`分隔（不编码）：
file=source.
php?/../../../../../../../../ffffllllaaaagggg
B. 使用两次编码的`?`（即`%253f`）并配合`../`：
file=source.
php%253f../../../../ffffllllaaaagggg
由于题目环境可能不同，两种方式都可能尝试。但引用[
1]中最终成功的URL是直接使用8次`../`，而引用[2]则使用了编码绕过。
因此，我们首先尝试引用[
1]的方法，如果不行再尝试引用[2]的方法。
具体步骤：
1. 访问题目提供的URL，例如：http://xxxxx.node4.buuoj.cn:8
1/
2. 查看页面，通常会有提示，比如一个笑脸图片，查看源代码可能也有提示。
3. 访问`hint.
php`，得到提示：flag在ffffllllaaaagggg文件中。
4. 访问`source.
php`（可能直接访问或通过`source.
php?file=source.
php`来查看源代码）。
5. 如果能看到源代码，分析其过滤逻辑。
假设我们无法直接查看源代码（题目没有给出），那么我们就尝试构造。
尝试A：
URL: http://xxxxx.node4.buuoj.cn:8
1/source.
php?file=source.
php?/../../../../../../../../ffffllllaaaagggg
尝试B：
URL: http://xxxxx.node4.buuoj.cn:8
1/source.
php?file=source.
php%253f../../../../../../../../ffffllllaaaagggg
注意：尝试B中，我们使用了8次`../`，与尝试A相同，只是将`?`替换为`%253f`。
如果尝试A或B成功，页面将显示ffffllllaaaagggg文件的内容，即flag。
另外，根据引用[
1]，他们成功访问的URL是：http://.../source.
php?file=source.
php?/../../../../../../../../ffffllllaaaagggg
所以，尝试A可能是直接有效的。
但是，为什么需要8次`../`？因为从当前目录到根目录需要多级回退。通常，Web根目录的深度不确定，所以需要不断尝试，直到成功。
因此，我们可以从4个`../`开始尝试，逐渐增加，直到8个或更多。
实际解题中，我们可以写一个脚本来尝试不同次数的`../`，或者手动增加。
总结解题步骤：
1. 访问`hint.
php`获取提示：flag在`ffffllllaaaagggg`中。
2. 尝试构造包含路径：
file=ffffllllaaaagggg -> 失败
file=../../ffffllllaaaagggg -> 失败（可能）
... 逐渐增加`../`的个数
file=../../../../../../../../ffffllllaaaagggg -> 可能失败，因为可能被过滤
3. 如果直接使用`../`被过滤，则尝试绕过：
file=source.
php?../../../../../../../../ffffllllaaaagggg （注意：这里有一个`?`，将参数分为两部分）
或者使用编码：file=source.
php%253f../../../../../../../../ffffllllaaaagggg
4. 如果以上都不行，可以尝试使用绝对路径（但通常不允许）或者利用其他漏洞。
根据引用内容，最终成功的方式是使用8个`../`并且配合`source.
php?`，即：
file=source.
php?/../../../../../../../../ffffllllaaaagggg
注意：在URL中，`?`是参数分隔符，所以我们在浏览器中实际输入的URL应该是：
http://xxxxx/source.
php?file=source.
php?/../../../../../../../../ffffllllaaaagggg
但是，这样会变成两个参数：第一个参数是`file=source.
php`，第二个参数是`/../../../../../../../../ffffllllaaaagggg`，这显然不是我们想要的。
所以，我们需要对第二个`?`进行编码，使其不被当作参数分隔符。因此，我们应该将第二个`?`进行URL编码，变成`%3f`，即：
http://xxxxx/source.
php?file=source.
php%3f/../../../../../../../../ffffllllaaaagggg
这样，`file`参数的值就是`source.
php%3f/../../../../../../../../ffffllllaaaagggg`，服务器接收到后会解码，得到`source.
php?/../../../../../../../../ffffllllaaaagggg`，然后由代码处理。
引用[
1]中直接使用了`?`而没有编码，可能是因为在浏览器中直接输入，浏览器会自动处理，或者题目环境特殊。但在实际中，我们需要编码，否则会被截断。
因此，正确的尝试应该是：
http://xxxxx/source.
php?file=source.
php%3f../../../../../../../../ffffllllaaaagggg
注意：这里在`source.
php%3f`后面没有加`/`，因为`%3f`代表`?`，而`?`后面的内容会被当作查询字符串，在文件包含中可能被忽略。所以，我们通常将路径放在`?`后面，但这样路径部分会被当作查询字符串而不是文件路径。
所以，我们可能需要调整：将路径放在`?`后面，但这样包含的是`source.
php`文件，并且传递了查询字符串，而不是包含`ffffllllaaaagggg`文件。
这看起来矛盾。因此，我们需要重新考虑引用[2]的绕过方式。
引用[2]中，他们构造的是：`?source.
php%253f../../../../flag.txt`。注意，这里是整个作为`file`参数的值。
所以，在URL中：
http://xxxxx/source.
php?file=source.
php%253f../../../../ffffllllaaaagggg
这样，`file`参数的值是`source.
php%253f../../../../ffffllllaaaagggg`。服务器接收到后，会进行一次URL解码（自动），得到`source.
php%3f../../../../ffffllllaaaagggg`（因为%253f解码为%3f）。
然后，在代码中，可能又进行了一次解码（比如调用urldecode函数），将`%3f`解码为`?`，于是变成`source.
php?../../../../ffffllllaaaagggg`。
然后，代码检查文件名部分（第一个`?`之前）是`source.
php`，在白名单内，所以允许包含。然后包含的是整个字符串，但包含文件时，`?`后面的部分会被当作查询字符串，所以实际上包含的是`source.
php`文件，而不是`ffffllllaaaagggg`。
这似乎也不对。所以，我们需要理解文件包含漏洞的利用方式：在
PHP中，当使用`include`包含文件时，如果文件名中有查询字符串，那么查询字符串会被当作传递给被包含文件的GET参数，但不会影响文件包含本身。也就是说，我们无法通过查询字符串来改变包含的文件。
那么，为什么引用[
1]和[2]都成功了呢？可能题目中的代码并不是直接包含，而是对参数进行了截取等操作。
因此，我们最好能查看`source.
php`的源代码。根据引用[
1]，我们可以通过`source.
php?file=source.
php`来查看源代码。所以，我们首先应该获取源代码。
步骤：
1. 访问：http://xxxxx/source.
php?file=source.
php
这样，如果题目允许，就会显示source.
php的源代码。
2. 分析源代码，了解过滤机制。
假设我们获取到了源代码（如引用[2]中提到的代码片段），我们可能会看到类似以下的关键代码：
```
php
<?
php
if (! empty($_REQUEST['file'])
&& is_string($_REQUEST['file'])
&& emmm::checkFile($_REQUEST['file'])
) {
include $_REQUEST['file'];
} else {
echo "<br><img src=\"https://i.loli.net/
2018/
11/0
1/5bdb0d93dc794.jpg\" />";
}
?>
```
并且有一个`emmm`类，其中包含`checkFile`方法。引用[2]提到，代码对`page`参数进行了两次检查，并且有一次解码。所以，我们需要仔细分析`checkFile`方法。
由于没有完整的源代码，我们只能推测。根据引用[2]的分析，我们可以尝试构造两次编码的`?`来绕过检查。
因此，我们再次尝试：
file=source.
php%253f../../../../ffffllllaaaagggg
但注意，我们实际要包含的是`ffffllllaaaagggg`，所以路径部分应该是正确的路径。如果`ffffllllaaaagggg`在根目录，那么8个`../`应该能到达根目录。
另外，引用[
1]中使用的成功URL是：http://.../source.
php?file=source.
php?/../../../../../../../../ffffllllaaaagggg
注意，这里有两个`?`，第一个`?`是分隔`source.
php`和参数`file`，第二个`?`是`file`参数值中的。在URL中，第二个`?`需要编码，否则会被当作第二个参数的分隔符。所以，在浏览器中输入时，第二个`?`会被截断，导致后面的路径丢失。
因此，我们必须将第二个`?`编码为`%3f`，即：
http://xxxxx/source.
php?file=source.
php%3f../../../../../../../../ffffllllaaaagggg
这样，整个`file`参数值就是`source.
php%3f../../../../../../../../ffffllllaaaagggg`。
服务器收到后，自动URL解码一次，变成`source.
php?../../../../../../../../ffffllllaaaagggg`，然后交给代码处理。
在代码的`checkFile`函数中，可能会将参数按`?`分割，取前面部分（`source.
php`）进行白名单检查，通过后，然后包含整个字符串。但是，包含整个字符串时，`?`后面的部分会被当作GET请求参数，所以实际包含的是`source.
php`文件，而不是我们想要的`ffffllllaaaagggg`。
那么，如何包含`ffffllllaaaagggg`呢？这里的关键是，在文件包含中，`?`后面的内容不会影响文件包含，但可以利用`../`来穿越目录，所以我们需要确保`?`前面的部分是一个正确的路径，直到我们想要的文件的路径。
但是，`source.
php?`显然不是一个目录，所以这种方法似乎行不通。
另一种常见的文件包含漏洞利用方式是使用`
php://filter`等伪协议，但本题要求包含一个具体文件，且题目提示了路径穿越，所以还是应该用目录穿越。
我们再看引用[2]的绕过方式：他们构造的是`?source.
php%253f../../../../flag.txt`，注意，这里没有在`source.
php`后面加`/`，而是直接跟`../../../../`。这样，当`%253f`被解码两次变成`?`后，整个字符串是`source.
php?../../../../flag.txt`，包含这个文件时，会尝试包含`source.
php`文件，并传递参数`../../../../flag.txt`，这显然不是我们想要的。
但是，引用[2]说他们成功了，所以可能题目的`checkFile`函数有特殊之处。我们推测`checkFile`函数可能对参数进行了递归检查，或者允许在文件名后添加路径。
由于没有源代码，我们只能猜测。另一种可能是：题目中的`checkFile`函数允许文件名为`source.
php`，并且允许包含的文件路径为`source.
php`，但后面的路径被当作目录，所以我们可以用`source.
php`作为目录名，然后穿越。显然，这是不可能的。
重新阅读引用[2]：“我们的参数应该是?source.
php…/…/…/flag.txt 而_page进行截断后判断白名单。 我们的参数就?source.
php?../…/…/flag.txt 对_page判断了两个 第二次是我们的绕过点，代码对page进行了一次解码，第一次判断为false，第二次为ture 我们的参数就变成了?source.
php%253f…/…/…/flag.txt”
这里，他们提到“对_page进行截断”，可能是指代码中会从参数中提取文件名，而文件名中如果有`?`，则`?`后面的内容会被当作参数，而文件名只取`?`前面的部分。所以，当参数是`source.
php?../flag.txt`时，提取的文件名是`source.
php`，在白名单中，通过检查。然后，在包含时，整个字符串`source.
php?../flag.txt`被包含，这时包含的是`source.
php`文件，并传递了参数`../flag.txt`，这并不会包含`flag.txt`。
所以，这个绕过方式的关键可能在于：题目中的代码在包含文件时，并不是用include($_REQUEST['file'])，而是有其他处理，比如将`?`后面的路径拼接到某个基础路径上？或者代码中存在一个截断漏洞（比如00截断）？但题目环境是
PHP，且版本未知。
鉴于题目的
writeup已经存在，我们按照成功经验操作。
根据多个
writeup，本题的解题payload为：
file=source.
php%253f../../../../ffffllllaaaagggg
或者：
file=source.
php?../../../../ffffllllaaaagggg （注意：这里的?要编码为%3f，否则URL会截断）
所以，我们在浏览器中输入的URL应该是：
http://xxxxx/source.
php?file=source.
php%253f../../../../ffffllllaaaagggg
或者：
http://xxxxx/source.
php?file=source.
php%3f../../../../ffffllllaaaagggg
但注意，%253f是%3f的URL编码，所以当浏览器发送请求时，%253f会被服务器解码为%3f，然后题目的代码可能再次解码%3f为?，所以最终变成`source.
php?../../../../ffffllllaaaagggg`。
然后，题目代码在检查时，会取`?`前的内容`source.
php`，发现它在白名单中，允许包含。然后包含整个字符串，而包含整个字符串时，?后面的部分../../../../ffffllllaaaagggg会被当作传递给source.
php的GET参数，所以实际执行的是source.
php，并打印出它的内容，而不是ffffllllaaaagggg的内容。
这与我们的预期不符。所以，我们可能误解了题目的代码。
查看网上公开的
writeup，我们找到了题目源代码（https://github.com/glzjin/CTF-
HCTF2018-warm
up/blob/master/source.
php）：
```
php
<?
php
highlight_file(__FILE__);
class emmm
{
public static function checkFile(&$page)
{
$whitelist = ["source"=>"source.
php","hint"=>"hint.
php"];
if (! isset($page) || !is_string($page)) {
echo "you can't see it";
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
echo "you can't see it";
return false;
}
}
if (! empty($_REQUEST['file'])
&& is_string($_REQUEST['file'])
&& emmm::checkFile($_REQUEST['file'])
) {
include $_REQUEST['file'];
exit;
} else {
echo "<br><img src=\"https://i.loli.net/
2018/
11/0
1/5bdb0d93dc794.jpg\" />";
}
?>
```
分析这段代码：
1. 首先，定义了一个白名单$whitelist，包含两个键值对，但值似乎没用，检查的是键（即"source"和"hint"）? 不对，检查的是$page是否在$whitelist数组中，而$whitelist数组的值是["source.
php", "hint.
php"]？ wait，代码中$whitelist = ["source"=>"source.
php","hint"=>"hint.
php"]; 这是一个关联数组，然后in_array($page, $whitelist) 这里$whitelist作为第二个参数，in_array会检查$page是否在数组的值中，即$page是否是"source.
php"或"hint.
php"。
2. 如果$page在$whitelist中，则返回true。
3. 否则，取$page中第一个`?`之前的部分（如果不存在`?`，则取整个字符串）作为$_page，然后检查$_page是否在白名单中。
4. 如果还不通过，则对$page进行URL解码，然后再取第一个`?`之前的部分，再检查是否在白名单中。
5. 如果通过，则包含$page。
所以，我们的绕过思路：
- 首先，$page = 'source.
php%3f../../../../ffffllllaaaagggg' （注意：这里%3f是?的编码）
- 第一次检查：$page='source.
php%3f../../../../ffffllllaaaagggg'，不在白名单中（白名单只有"source.
php"和"hint.
php"）。
- 然后，取第一个`?`之前的部分：因为$page中没有`?`，所以取整个字符串，即'source.
php%3f../../../../ffffllllaaaagggg'，不在白名单中。
- 接着，对$page进行URL解码，得到：'source.
php?../../../../ffffllllaaaagggg'
- 然后，再取第一个`?`之前的部分：'source.
php'，在白名单中，返回true。
因此，我们构造的$page='source.
php%3f../../../../ffffllllaaaagggg' 能够通过检查。
然后，代码执行：include 'source.
php%3f../../../../ffffllllaaaagggg'
但是，include函数会尝试包含文件名为'source.
php%3f../../../../ffffllllaaaagggg'的文件，而这样的文件不存在。
所以，我们需要将%3f解码为?，但include函数不会自动URL解码。所以，我们需要服务器在接收到参数时已经进行了一次URL解码。
实际上，在
PHP中，$_REQUEST['file']在传递给checkFile之前，已经被
PHP自动进行了一次URL解码（这是
PHP的特性）。所以，当我们的参数是`source.
php%253f../../../../ffffllllaaaagggg`时，
PHP自动解码%25为%，得到`source.
php%3f../../../../ffffllllaaaagggg`，然后这个字符串传递给checkFile。
在checkFile中，第一次检查时，字符串是`source.
php%3f../../../../ffffllllaaaagggg`，其中没有`?`，所以取整个字符串，不在白名单中。
然后，进行URL解码（urldecode函数），得到`source.
php?../../../../ffffllllaaaagggg`，然后取第一个`?`之前的部分，即`source.
php`，在白名单中，返回true。
然后，include的参数是`source.
php%3f../../../../ffffllllaaaagggg`（注意，这是经过
PHP自动解码后的，但%3f没有被解码，因为自动解码只做一次）。
所以，include会尝试包含一个名为`source.
php%3f../../../../ffffllllaaaagggg`的文件，而这个文件不存在。
这里，我们犯了一个错误：在传递给include时，我们希望的是`source.
php?../../../../ffffllllaaaagggg`，但实际是`source.
php%3f../../../../ffffllllaaaagggg`，因为%3f没有解码。
所以，我们需要在checkFile通过后，include的时候，文件名字符串是`source.
php?../../../../ffffllllaaaagggg`。但如何做到呢？
我们回顾：当我们传递参数为`file=source.
php%253f../../../../ffffllllaaaagggg`时：
-
PHP自动解码%25->%，得到`source.
php%3f../../../../ffffllllaaaagggg`，存入$_REQUEST['file']。
- 然后checkFile函数对这个字符串进行检查，在函数内部，它对这个字符串进行urldecode，得到`source.
php?../../../../ffffllllaaaagggg`，然后检查通过。
- 然后include($_REQUEST['file'])，即include('source.
php%3f../../../../ffffllllaaaagggg')。
所以，问题在于include的参数是urldecode之前的字符串，而checkFile检查的是urldecode之后的。
因此，我们需要在checkFile通过后，include时，参数是urldecode过的。但代码中include的是$_REQUEST['file']，它是urldecode之前的。
那么，我们再看checkFile的签名：`emmm::checkFile($_REQUEST['file'])`，这里传递的是引用，所以如果在checkFile内部修改了$page，那么外部的$_REQUEST['file']也会变吗？ 不会，因为
PHP中函数参数传递默认是值传递，除非显式引用传递（&）。在代码中，函数定义是`checkFile(&$page)`，所以是引用传递。
在checkFile函数中，我们执行了`$_page = urldecode($page);`，但$page本身没有被改变。然后，我们只是用$_page进行了检查，并没有修改$page。所以，$page还是`source.
php%3f../../../../ffffllllaaaagggg`。
所以，我们需要在checkFile函数中，在urldecode之后，把$page设置为urldecode后的字符串，这样include时就能包含正确的文件。
但是，题目代码没有这样做。所以，我们只能利用两次urldecode。
我们尝试三重编码：
- 我们传递：`file=source.
php%25253f../../../../ffffllllaaaagggg`
-
PHP自动解码一次：%25->%，得到`source.
php%253f../../../../ffffllllaaaagggg`
- 然后，在checkFile中：
第一次检查：不在白名单
然后取?前：整个字符串，不在
然后，urldecode($page) ：%253f -> %3f（因为%25解码为%），得到`source.
php%3f../../../../ffffllllaaaagggg`
然后，取?前：整个字符串（因为没有?），不在
然后，echo "you can't see it"; 返回false。
所以，三重编码不行。
回到二重编码：`file=source.
php%253f../../../../ffffllllaaaagggg`
-
PHP自动解码：%25->%，得到`source.
php%3f../../../../ffffllllaaaagggg`
- checkFile:
第一次检查：不在
取?前：整个字符串，不在
urldecode($page): %3f->?，得到`source.
php?../../../../ffffllllaaaagggg`
取?前：`source.
php`，在白名单中，返回true。
- include: `source.
php%3f../../../../ffffllllaaaagggg` -> 文件不存在。
怎么办？我们希望include的时候是`source.
php?../../../../ffffllllaaaagggg`，但实际是`source.
php%3f../../../../ffffllllaaaagggg`。
所以，我们需要的不是 include('source.
php?../../../../ffffllllaaaagggg')，而是 include('../../../../ffffllllaaaagggg')。
那么，我们能否让$page最终是`../../../../ffffllllaaaagggg`？ 但checkFile会检查，直接写`../../../../ffffllllaaaagggg`肯定通不过。
我们再看源代码，发现checkFile中有一个步骤：
$_page = mb_substr($page,0,mb_strpos($page.'?','?'));
在urldecode之前，如果我们传一个字符串，其中包含一个编码过的?（%3f），那么mb_strpos($page.'?','?')会找不到%3f，所以会取整个字符串。然后urldecode后，就会变成?，然后取?之前的部分。
所以，我们只能让urldecode后的字符串中包含?，并且?前面是白名单中的文件。
但是，include的时候，我们需要包含的是穿越目录后的文件，而不是 source.
php?xxx。
这里，我们就要利用 include 的一个特性：include 会 include 指定路径的文件，而 ? 后面的部分会被当作 querystring，对于
PHP 文件来说，querystring 会作为 $_GET 参数，但不会改变 include 的文件路径。但是，如果我们 include 的是一个不存在的文件，比如 `source.
php?../../../../ffffllllaaaagggg`，那么 include 会尝试 include `source.
php` 文件，而 `?../../../../ffffllllaaaagggg` 作为 querystring 会被忽略，所以还是 include 了 `source.
php` 文件。
所以，这种方法 include 的始终是 `source.
php`，而不是我们想要的 flag 文件。
那么，本题是如何解决的呢？ 答案是利用 checkFile 函数的 urldecode 之后的检查通过后，$page 虽然没变，但是 include 的路径我们可以用穿越目录来 include 其他目录的文件。
我们再看 checkFile 函数的urldecode之后的部分：
$_page = urldecode($page);
$_page = mb_substr($_page,0,mb_strpos($_page . '?', '?'));
if (in_array($_page, $whitelist)) {
return true;
}
这里，urldecode($page) 得到一个新字符串，然后取urldecode后的字符串中?前的内容，如果在白名单中，就返回true。
注意，这里urldecode($page) 可能包含../，比如 $page='source.
php%3f../../../../ffffllllaaaagggg'，urldecode后是 'source.
php?../../../../ffffllllaaaagggg'，然后取?前是 'source.
php'，通过。
然后 include($page) 时，$page 还是 'source.
php%3f../../../../ffffllllaaaagggg'， include 会尝试 include 'source.
php%3f../../../../ffffllllaaaagggg' 文件，这个文件肯定不存在。
这里的关键是： include 函数在找不到文件时，会报 warning，但不会停止执行。而且，include 会 include 指定路径的文件，而 路径穿越 必须放在?前面，否则会被当作 querystring。
所以，我们构造：$page='source.
php/../../../../ffffllllaaaagggg'
但 source.
php 是一个文件，不能作为目录。
那么我们 try: $page='hint.
php/../../../../ffffllllaaaagggg'
也不行，因为 hint.
php 是文件。
所以，我们只能让?前的部分是白名单中的文件， then after the ? we put the payload, but that won't work for include.
publicly available
writeup (e.g., https://blog.youkuaiyun.com/weixin_ er_ article_ type=
1) 中提到 payload 是： file=source.
php%253f../../../../ffffllllaaaagggg
but they also say that it is for bypassing the check, and then the include will include the flag file.
How? include('source.
php%3f../../../../ffffllllaaaagggg') will try to open a file with that name, and the %3f is not decoded, so it's not a directory separator.
Another possibility: the include function in
PHP will also include files from the include_path, and/or use the .. to go
up. But the string is not a valid path because of the %3f.
Perhaps the
writeup is for a different version of the code.
Given the time, we try the following payload manually in the browser:
payload
1: file=../../../../ffffllllaaaagggg
payload2: file=source.
php?../../../../ffffllllaaaagggg -> URL: file=source.
php%3f../../../../ffffllllaaaagggg
payload3: file=source.
php%253f../../../../ffffllllaaaagggg
payload4: file=source.
php?/../../../../ffffllllaaaagggg -> file=source.
php%3f/../../../../ffffllllaaaagggg
payload5: file=source.
php%253f/../../../../ffffllllaaaagggg
payload6: file=source.
php/../../../../ffffllllaaaagggg -> might be blocked by the check.
payload7: file=source.
php/./././././././././ffffllllaaaagggg -> doesn't make sense.
payload8: file=source.
php/../../../../ffffllllaaaagggg -> URL: file=source.
php%2f..%2f..%2f..%2f..%2ffffllllaaaagggg
But this will fail the check because the first part is 'source.
php%2f..%2f..%2f..%2f..%2ffffllllaaaagggg' which is not in the whitelist.
So, the intended solution is to use the double encoding of the ? to pass the check, and then the include will include the file as: 'source.
php?../../../../ffffllllaaaagggg' which is not what we want, but in the publicly available
writeup, they say it works.
I found a
writeup that explains: https://www.freebuf.com/articles/web/2
16543.html
According to it, the payload is: file=source.
php?../../../../../../../../ffffllllaaaagggg
and they stress that the ? must be URL-encoded as %3f when passed in the URL.
So, the full URL is: http://xxx/source.
php?file=source.
php%3f..%2f..%2f..%2f..%2f..%2f..%2f..%2ffffllllaaaagggg
But they also include the / as %2f to avoid being blocked by the . in the ../
However, in our case, the code does not seem to block . or /, only the whitelist check.
So, why would it work? The
writeup does not explain, but they say it does.
Another possibility: the include function will include the file if it is a valid path, and the ? in the filename is not allowed, so it fails, and then the include_path is used, and the .. are processed. But this is not standard.
Given the confusion, I will try to simulate the include with the string 'source.
php?../../../../ffffllllaaaagggg' in a
PHP environment. Let's create a test.
php:
```
php
<?
php
$file = 'source.
php?../../../../ffffllllaaaagggg';
include $file;
?>
```
This will try to include 'source.
php?../../../../ffffllllaaaagggg' file, which does not exist. So it will show a warning.
Therefore, the only way is to have the ? in the filename to be directory separator, which it is not.
We must be missing something.
Let me re-examine the code: the checkFile function is:
```
php
public static function checkFile(&$page)
{
$whitelist = ["source"=>"source.
php","hint"=>"hint.
php"];
if (! isset($page) || !is_string($page)) {
echo "you can't see it";
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
echo "you can't see it";
return false;
}
```
In the second check (after the first in_array fails), we have:
$_page = mb_substr($page,0,mb_strpos($page.'?','?'));
For example, if $page='source.
php?../../../../ffffllllaaaagggg' ( note: this is after the auto-urldecode by
PHP and then the checkFile's own urldecode, but in this context, we are in the first of the two additional checks, before any urldecode in the function).
Let's assume $page='source.
php%3f../../../../ffffllllaaaagggg' (at the beginning of the function) because we passed %3f in the URL and it was auto-decode to %3f ( so the? is not there).
Then, in the first additional check:
$_page = mb_substr($page,0,mb_strpos($page.'?','?'));
// $page is 'source.
php%3f../../../../ffffllllaaaagggg'
// $page.'?' = 'source.
php%3f../../../../ffffllllaaaagggg?'
// mb_strpos($page.'?', '?') -> we are looking for '?' in the string, and it is at position len($page) (at the appended '?').
// So, it will return the position of the appended '?', which is the length of the string without the appended '?'.
// Therefore, mb_substr will return the whole string.
Then, in_array on the whole string fails.
Then, we do: $_page = urldecode($page) = 'source.
php?../../../../ffffllllaaaagggg'
Then, $_page = mb_substr($_page,0,mb_strpos($_page.'?','?')) = mb_sub
本文介绍了通过查看网页源代码、找到Git链接并解密Session来模拟登录管理员账号的过程。涉及Flask框架的安全漏洞利用，包括解码Session字符串，修改用户信息再加密，并将加密后的Session写入Cookie实现非法登录。
扫一扫
577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
