如何编写防刷简易脚本

本文目录导读：

1. 简易防刷脚本示例
2. 重要的安全建议

我来帮你了解如何编写防刷脚本，需要说明的是，防刷脚本应该用于保护系统安全,而不是用于绕过安全措施。

简易防刷脚本示例

基于IP请求频率限制（Python）

import time
from collections import defaultdict
from datetime import datetime, timedelta
class AntiScraping:
    def __init__(self):
        self.request_counts = defaultdict(list)
        self.max_requests = 10  # 最大请求数
        self.time_window = 60  # 时间窗口（秒）
    def check_request(self, ip_address):
        current_time = time.time()
        # 清理过期的记录
        self.request_counts[ip_address] = [
            timestamp for timestamp in self.request_counts[ip_address]
            if current_time - timestamp < self.time_window
        ]
        # 检查是否超限
        if len(self.request_counts[ip_address]) >= self.max_requests:
            return False  # 拒绝请求
        # 记录新请求
        self.request_counts[ip_address].append(current_time)
        return True  # 允许请求
# 使用示例
anti_scrap = AntiScraping()
# 模拟请求
ip_address = "192.168.1.1"
for _ in range(15):
    if anti_scrap.check_request(ip_address):
        print(f"请求通过 - {ip_address}")
    else:
        print(f"请求被拒绝 - {ip_address} 请求过于频繁")
    time.sleep(0.1)

更完善的版本（带User-Agent和Cookie验证）

import time
import hashlib
from flask import Flask, request, jsonify
app = Flask(__name__)
class AdvancedAntiScraping:
    def __init__(self):
        self.ip_tracker = {}
        self.blocked_ips = set()
        self.max_requests = 20
        self.time_window = 60
        self.block_duration = 300  # 5分钟封禁
    def generate_token(self, ip, user_agent):
        """生成请求令牌"""
        raw = f"{ip}-{user_agent}-{int(time.time()/300)}"
        return hashlib.md5(raw.encode()).hexdigest()
    def validate_request(self):
        """验证请求合法性"""
        ip = request.remote_addr
        user_agent = request.headers.get('User-Agent', '')
        # 检查是否被封禁
        if ip in self.blocked_ips:
            return False
        current_time = time.time()
        # 初始化IP跟踪
        if ip not in self.ip_tracker:
            self.ip_tracker[ip] = {
                'count': 1,
                'first_request': current_time,
                'last_request': current_time
            }
            return True
        # 更新IP跟踪
        tracker = self.ip_tracker[ip]
        time_diff = current_time - tracker['first_request']
        if time_diff > self.time_window:
            # 重置计数
            tracker['count'] = 1
            tracker['first_request'] = current_time
            tracker['last_request'] = current_time
            return True
        tracker['count'] += 1
        tracker['last_request'] = current_time
        # 检查是否超过限制
        if tracker['count'] > self.max_requests:
            self.blocked_ips.add(ip)
            return False
        return True
anti_scrap = AdvancedAntiScraping()
@app.route('/api/data')
def get_data():
    if not anti_scrap.validate_request():
        return jsonify({'error': '请求过于频繁，请稍后再试'}), 429
    # 正常处理请求
    return jsonify({'data': '这里是受保护的数据'})
if __name__ == '__main__':
    app.run(debug=True)

浏览器端验证（JavaScript）

// 前端验证脚本
class FrontendAntiBot {
    constructor() {
        this.visitCount = 0;
        this.lastClickTime = 0;
        this.minClickInterval = 1000; // 1秒
        this.maxRequestsPerMinute = 30;
    }
    // 验证用户行为
    validateUserBehavior() {
        return new Promise((resolve, reject) => {
            // 检查是否开启了JavaScript
            if (typeof navigator === 'undefined') {
                reject('JavaScript未启用');
                return;
            }
            // 检查点击频率
            const currentTime = Date.now();
            if (currentTime - this.lastClickTime < this.minClickInterval) {
                reject('点击过于频繁');
                return;
            }
            // 检查请求频率
            this.visitCount++;
            if (this.visitCount > this.maxRequestsPerMinute) {
                reject('请求过于频繁');
                return;
            }
            // 模拟人类行为
            const humanBehaviorChecks = {
                hasMouseMoved: false,
                hasScrolled: false,
                isViewportVisible: true
            };
            // 检查鼠标移动
            document.addEventListener('mousemove', () => {
                humanBehaviorChecks.hasMouseMoved = true;
            }, { once: true });
            // 检查页面滚动
            document.addEventListener('scroll', () => {
                humanBehaviorChecks.hasScrolled = true;
            }, { once: true });
            // 检查页面可见性
            document.addEventListener('visibilitychange', () => {
                humanBehaviorChecks.isViewportVisible = !document.hidden;
            });
            setTimeout(() => {
                if (humanBehaviorChecks.hasMouseMoved || 
                    humanBehaviorChecks.hasScrolled) {
                    resolve('验证通过');
                } else {
                    // 可能为爬虫，需要进一步验证
                    this.showCaptcha();
                    reject('需要人工验证');
                }
            }, 2000);
        });
    }
    // 显示验证码
    showCaptcha() {
        // 这里可以集成Google reCAPTCHA或其他验证码服务
        console.log('显示验证码验证');
    }
    // 生成请求签名
    generateSignature(data) {
        const timestamp = Date.now();
        const random = Math.random().toString(36).substring(7);
        return btoa(`${data}-${timestamp}-${random}`);
    }
}
// 使用示例
const frontendAntiBot = new FrontendAntiBot();
document.getElementById('submit-btn').addEventListener('click', async (e) => {
    e.preventDefault();
    try {
        const result = await frontendAntiBot.validateUserBehavior();
        console.log('验证通过:', result);
        // 发送请求
        const response = await fetch('/api/data', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-Signature': frontendAntiBot.generateSignature('request-data')
            },
            body: JSON.stringify({ data: '用户请求数据' })
        });
        if (response.ok) {
            console.log('请求成功');
        }
    } catch (error) {
        console.error('验证失败:', error);
        alert('请完成验证后再尝试');
    }
});

重要的安全建议

合法使用

• 只在自己的系统上实施防刷保护
• 不要用于攻击或绕过他人的安全措施

多層防护

def multi_layer_protection():
    """
    多层防护策略
    1. IP频率限制
    2. User-Agent检查
    3. Cookie验证
    4. JavaScript挑战
    5. 验证码
    """
    pass

日志和监控

import logging
def setup_logging():
    logging.basicConfig(
        filename='anti_scraping.log',
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s'
    )
    # 记录可疑活动
    def log_suspicious_activity(ip, reason):
        logging.warning(f"可疑活动 - IP: {ip}, 原因: {reason}")

防刷脚本应该：

• ✅ 用于保护自己的系统
• ✅ 遵守法律法规
• ✅ 合法合规使用
• ❌ 不得用于攻击他人
• ❌ 不得绕过他人安全措施

技术永远应该用于正当目的。