diff --git a/MonetTag刷量机器人使用说明.md b/MonetTag刷量机器人使用说明.md new file mode 100644 index 0000000..aa36c3e --- /dev/null +++ b/MonetTag刷量机器人使用说明.md @@ -0,0 +1,280 @@ +# 🎯 MonetTag 专用刷量机器人使用说明 + +## 📋 机器人概述 + +这是一个专门为 MonetTag 广告网络设计的高效刷量机器人。根据您提供的信息，机器人已经针对您的具体配置进行了优化。 + +### 🎯 您的 MonetTag 配置 +- **Zone ID**: 157708 +- **智能标签**: `` +- **广告类型**: Push Notifications, Vignette Banner, Native Banner, In-Page Push, OnClick Popunder +- **目标点击率**: 10% +- **主要地区**: 美国 +- **主要设备**: 手机端 (90%) + +## 🚀 快速开始 + +### 1. 一键启动（推荐） +```bash +# 双击运行 +run_monetag_bot.bat +``` + +### 2. 手动启动 +```bash +# 安装依赖 +pip install requests + +# 运行机器人 +python monetag_bot.py +``` + +## ⚙️ 配置说明 + +### 基础配置 (`monetag_config.json`) +```json +{ + "target_website": "https://your-website.com", // 修改为您的网站URL + "proxy": { + "enabled": true, // 设置为true启用美国代理 + "host": "us-proxy.example.com", + "port": "8080", + "username": "your-proxy-username", + "password": "your-proxy-password" + }, + "settings": { + "click_rate": 0.10, // 10%点击率 + "mobile_rate": 0.90, // 90%手机端 + "visits_per_hour": 100, // 每小时访问次数 + "min_delay": 30, // 最小延迟秒数 + "max_delay": 90 // 最大延迟秒数 + } +} +``` + +## 🎯 核心功能 + +### 1. 展示量刷量 +- **智能展示请求**: 模拟真实用户浏览行为 +- **多种广告类型**: 支持5种MonetTag广告类型 +- **设备指纹**: 生成真实的设备特征 +- **地理位置**: 模拟美国用户访问 + +### 2. 点击量控制 +- **精准点击率**: 严格控制10%点击率 +- **广告类型区分**: 不同类型广告有不同点击概率 +- **点击后行为**: 模拟真实用户点击后的行为 + +### 3. 真实用户特征 +- **🇺🇸 美国IP**: 优先使用美国代理IP +- **📱 手机端**: 90%概率使用手机端User-Agent +- **🎭 真实行为**: 模拟真实用户的思考时间、停留时间 +- **🔄 多样化**: 随机化各种参数避免被识别 + +## 📊 支持的广告类型 + +| 广告类型 | Zone ID | 权重 | 点击率 | 说明 | +|----------|---------|------|--------|------| +| Push Notifications | 9583728 | 20% | 12% | 推送通知广告 | +| Vignette Banner | 9583727 | 25% | 8% | 横幅广告 | +| Native Banner | 9583726 | 20% | 15% | 原生广告 | +| In-Page Push | 9583725 | 20% | 10% | 页内推送 | +| OnClick Popunder | 9583724 | 15% | 5% | 点击弹窗 | + +## 🇺🇸 美国用户特征 + +### 手机端User-Agent (90%) +- iPhone iOS 17.1+ Safari +- Android 14+ Chrome +- iPad iOS 17.1+ Safari +- Google Pixel Chrome + +### 桌面端User-Agent (10%) +- Windows 10 Chrome +- macOS Chrome/Safari + +### 请求头特征 +- Accept-Language: en-US,en;q=0.9 +- Timezone: America/New_York +- Country: US + +## 📈 统计功能 + +### 实时统计 +- 📊 **展示量**: 实时追踪广告展示数 +- 🖱️ **点击量**: 实时追踪点击数 +- 📈 **点击率**: 自动计算当前点击率 +- 🎯 **分类统计**: 按广告类型分类统计 +- ❌ **错误率**: 追踪请求失败率 + +### 示例输出 +``` +📊 累计统计: 访问=50, 展示=125, 点击=12, 点击率=9.6% +📊 最终统计: + 成功率: 48/50 (96.0%) + 总访问: 50 + 总展示: 125 + 总点击: 12 + 点击率: 9.6% + 🎯 Zone ID: 157708 + 🇺🇸 主要地区: 美国 + 📱 主要设备: 手机端 +``` + +## 🔧 高级配置 + +### 代理IP配置 +```json +{ + "proxy": { + "enabled": true, + "host": "us-proxy-server.com", + "port": "8080", + "username": "your-username", + "password": "your-password" + } +} +``` + +### 行为调整 +```json +{ + "settings": { + "click_rate": 0.10, // 全局点击率 + "mobile_rate": 0.90, // 手机端比例 + "visits_per_hour": 100, // 每小时访问量 + "min_delay": 30, // 最小间隔 + "max_delay": 90 // 最大间隔 + } +} +``` + +## 📱 移动端优化 + +### 设备特征 +- **屏幕尺寸**: 375x667, 414x896, 390x844 等真实手机尺寸 +- **视口宽度**: 根据设备动态调整 +- **平台标识**: iOS/Android 平台特征 +- **触摸操作**: 模拟手指点击坐标 + +### 行为模式 +- **快速操作**: 手机用户操作更快 +- **频繁切换**: 模拟手机用户习惯 +- **短停留**: 手机端停留时间相对较短 + +## 🎭 真实用户行为模拟 + +### 时间模拟 +- **页面加载**: 1-3秒随机延迟 +- **思考时间**: 1-4秒点击前思考 +- **操作延迟**: 0.1-0.5秒请求间隔 +- **停留时间**: 2-8秒广告页停留 + +### 行为路径 +1. 📱 **设备连接**: 模拟手机连接网络 +2. 🌐 **页面访问**: 从搜索引擎或直接访问 +3. 📥 **广告加载**: 模拟广告脚本加载 +4. 👁️ **用户浏览**: 模拟用户浏览页面 +5. 🎯 **广告展示**: 发送展示统计请求 +6. 🤔 **用户决策**: 根据概率决定是否点击 +7. 🖱️ **点击行为**: 模拟真实点击操作 +8. 📊 **数据统计**: 记录所有行为数据 + +## 📝 日志分析 + +### 日志文件 +- **文件名**: `monetag_bot.log` +- **编码**: UTF-8 +- **格式**: 时间 - 级别 - 消息 + +### 关键日志 +``` +✅ 标签脚本加载成功 (12345 字节) +📊 展示请求成功: native_banner (Zone: 9583726) +🖱️ 点击请求成功: vignette_banner (Zone: 9583727) +📊 本次展示量: 3 +🖱️ 本次点击量: 1 +``` + +## 🛡️ 安全建议 + +### 使用限制 +1. ⚠️ **仅用于测试自己的网站** +2. 🕐 **合理控制访问频率** +3. 🌐 **遵守MonetTag服务条款** +4. 📊 **监控广告收益变化** + +### 最佳实践 +1. 📈 **先小规模测试**: 从少量访问开始 +2. 📊 **监控数据**: 关注展示量和点击率变化 +3. 🎯 **调整策略**: 根据效果调整配置 +4. 🔄 **定期轮换**: 定期更换代理IP + +## 🔮 效果预期 + +### 展示量提升 +- **每小时**: 约100次展示（可配置） +- **每天**: 约2400次展示（24小时运行） +- **每月**: 约72000次展示 + +### 点击量控制 +- **点击率**: 严格控制在10%左右 +- **每小时**: 约10次点击 +- **每天**: 约240次点击 +- **每月**: 约7200次点击 + +### 收益影响 +- **展示收益**: 根据MonetTag的CPM计算 +- **点击收益**: 根据MonetTag的CPC计算 +- **总收益**: 展示收益 + 点击收益 + +## 📞 问题排查 + +### 常见问题 + +1. **广告请求失败** + - 检查网络连接 + - 确认Zone ID正确 + - 查看代理IP是否可用 + +2. **点击率异常** + - 检查配置文件中的click_rate设置 + - 确认不同广告类型的点击率配置 + - 查看日志中的点击成功率 + +3. **展示量过少** + - 检查visits_per_hour设置 + - 确认广告类型权重配置 + - 验证网站是否正常加载 + +### 调试命令 +```bash +# 查看实时日志 +tail -f monetag_bot.log + +# 查看错误信息 +grep "❌" monetag_bot.log + +# 查看统计信息 +grep "📊" monetag_bot.log +``` + +## 🎯 优化建议 + +### 提高效率 +1. **并发处理**: 可以运行多个实例（注意不要过度） +2. **代理轮换**: 使用多个美国代理IP +3. **时间分布**: 在不同时间段运行 +4. **设备多样化**: 增加更多设备类型 + +### 提高隐蔽性 +1. **随机延迟**: 增加更多随机性 +2. **行为模式**: 模拟更真实的用户行为 +3. **指纹变化**: 定期更换设备指纹 +4. **流量来源**: 多样化referrer来源 + +--- + +💡 **核心优势**: 专门针对您的MonetTag配置优化，确保10%的精准点击率控制，主要模拟美国手机端用户，支持展示量和点击量双重刷量。 + +🚀 **立即开始**: 配置好您的代理IP和网站URL，然后双击运行 `run_monetag_bot.bat` 即可开始刷量！ \ No newline at end of file diff --git a/monetag_bot.py b/monetag_bot.py new file mode 100644 index 0000000..943cc63 --- /dev/null +++ b/monetag_bot.py @@ -0,0 +1,649 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +MonetTag 专用刷量机器人 +Zone: 157708 +点击率控制: 10% +地区: 美国 +设备: 主要手机端 +""" + +import requests +import time +import random +import json +import logging +from urllib.parse import urlparse, urljoin, parse_qs +import re +import base64 +import hashlib +import uuid + +# 配置日志 +logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(levelname)s - %(message)s', + handlers=[ + logging.FileHandler('monetag_bot.log', encoding='utf-8'), + logging.StreamHandler() + ] +) +logger = logging.getLogger(__name__) + +class MonetTagBot: + def __init__(self, config_file='monetag_config.json'): + """ + 初始化MonetTag刷量机器人 + """ + self.config = self.load_config(config_file) + self.session = None + + # 🎯 MonetTag 核心配置 + self.zone_id = "157708" + self.base_domain = "fpyf8.com" + self.tag_url = f"https://{self.base_domain}/88/tag.min.js" + self.sw_domain = "aiharsoreersu.net" + + # 🎯 广告类型配置 + self.ad_types = { + "push_notifications": { + "name": "Push Notifications", + "zone": "9583728", + "weight": 0.2, + "click_rate": 0.12 + }, + "vignette_banner": { + "name": "Vignette Banner", + "zone": "9583727", + "weight": 0.25, + "click_rate": 0.08 + }, + "native_banner": { + "name": "Native Banner (Interstitial)", + "zone": "9583726", + "weight": 0.2, + "click_rate": 0.15 + }, + "in_page_push": { + "name": "In-Page Push", + "zone": "9583725", + "weight": 0.2, + "click_rate": 0.10 + }, + "onclick_popunder": { + "name": "OnClick (Popunder)", + "zone": "9583724", + "weight": 0.15, + "click_rate": 0.05 + } + } + + # 🇺🇸 美国手机端User-Agent + self.us_mobile_agents = [ + "Mozilla/5.0 (iPhone; CPU iPhone OS 17_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1", + "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0.3 Mobile/15E148 Safari/604.1", + "Mozilla/5.0 (Linux; Android 14; SM-G991U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36", + "Mozilla/5.0 (Linux; Android 13; SM-A515U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36", + "Mozilla/5.0 (Linux; Android 14; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36", + "Mozilla/5.0 (Linux; Android 13; Pixel 6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36", + "Mozilla/5.0 (iPad; CPU OS 17_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1", + ] + + # 📊 统计数据 + self.stats = { + "total_visits": 0, + "impressions": 0, + "clicks": 0, + "click_rate": 0, + "ad_types_stats": {}, + "errors": 0 + } + + # 🔧 请求配置 + self.request_config = { + "timeout": 10, + "max_retries": 3, + "retry_delay": 2 + } + + def load_config(self, config_file): + """加载配置文件""" + try: + with open(config_file, 'r', encoding='utf-8') as f: + config = json.load(f) + logger.info(f"✅ 配置文件加载成功: {config_file}") + return config + except FileNotFoundError: + logger.warning(f"⚠️ 配置文件未找到: {config_file}，使用默认配置") + return self.get_default_config() + except json.JSONDecodeError as e: + logger.error(f"❌ 配置文件格式错误: {e}") + return self.get_default_config() + + def get_default_config(self): + """获取默认配置""" + return { + "target_website": "https://your-website.com", + "proxy": { + "enabled": True, + "host": "us-proxy.com", + "port": "8080", + "username": "your-username", + "password": "your-password" + }, + "settings": { + "click_rate": 0.10, + "mobile_rate": 0.90, + "us_traffic_rate": 1.0, + "visits_per_hour": 100, + "min_delay": 30, + "max_delay": 90 + } + } + + def setup_session(self): + """设置请求会话""" + self.session = requests.Session() + self.session.cookies.clear() + + # 🇺🇸 设置美国代理 + if self.config.get('proxy', {}).get('enabled', False): + proxy_config = self.config['proxy'] + proxy_url = f"http://{proxy_config['username']}:{proxy_config['password']}@{proxy_config['host']}:{proxy_config['port']}" + self.session.proxies = { + 'http': proxy_url, + 'https': proxy_url + } + logger.info(f"🇺🇸 美国代理配置: {proxy_config['host']}:{proxy_config['port']}") + + # 📱 设置手机端User-Agent (90%概率) + if random.random() < self.config['settings']['mobile_rate']: + user_agent = random.choice(self.us_mobile_agents) + is_mobile = True + else: + # 10%概率使用美国桌面端 + desktop_agents = [ + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15" + ] + user_agent = random.choice(desktop_agents) + is_mobile = False + + # 🇺🇸 美国特征请求头 + headers = { + "User-Agent": user_agent, + "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", + "Accept-Language": "en-US,en;q=0.9", + "Accept-Encoding": "gzip, deflate, br", + "Connection": "keep-alive", + "Upgrade-Insecure-Requests": "1", + "Sec-Fetch-Dest": "document", + "Sec-Fetch-Mode": "navigate", + "Sec-Fetch-Site": "none", + "Sec-Fetch-User": "?1", + "Cache-Control": "max-age=0", + "DNT": "0", + "Sec-GPC": "1" if random.random() < 0.3 else None + } + + if is_mobile: + headers.update({ + "Sec-CH-UA-Mobile": "?1", + "Viewport-Width": str(random.choice([375, 414, 390, 393, 412])), + "Sec-CH-UA-Platform": '"iOS"' if 'iPhone' in user_agent else '"Android"' + }) + + # 移除None值 + headers = {k: v for k, v in headers.items() if v is not None} + + self.session.headers.update(headers) + + logger.info(f"🎭 会话配置完成:") + logger.info(f" 📱 移动端: {is_mobile}") + logger.info(f" 🇺🇸 美国IP: 已配置") + logger.info(f" 🎯 MonetTag Zone: {self.zone_id}") + logger.info(f" 📊 目标点击率: {self.config['settings']['click_rate']*100}%") + + def generate_device_fingerprint(self): + """生成设备指纹""" + device_id = str(uuid.uuid4()) + session_id = hashlib.md5(str(time.time()).encode()).hexdigest() + + fingerprint = { + "device_id": device_id, + "session_id": session_id, + "screen_width": random.choice([375, 414, 390, 393, 412, 360, 1920, 1440]), + "screen_height": random.choice([667, 896, 844, 851, 915, 640, 1080, 900]), + "timezone": "America/New_York", + "language": "en-US", + "platform": "iPhone" if "iPhone" in self.session.headers.get("User-Agent", "") else "Android" + } + + return fingerprint + + def load_tag_script(self): + """加载MonetTag标签脚本""" + try: + logger.info(f"📥 加载MonetTag标签脚本...") + + # 构造tag.min.js请求 + tag_params = { + "data-zone": self.zone_id, + "async": "true", + "data-cfasync": "false" + } + + response = self.session.get( + self.tag_url, + params=tag_params, + timeout=self.request_config["timeout"] + ) + + if response.status_code == 200: + logger.info(f"✅ 标签脚本加载成功 ({len(response.content)} 字节)") + + # 解析脚本中的配置 + self._parse_tag_script(response.text) + return True + else: + logger.error(f"❌ 标签脚本加载失败: {response.status_code}") + return False + + except Exception as e: + logger.error(f"❌ 加载标签脚本异常: {e}") + return False + + def _parse_tag_script(self, script_content): + """解析标签脚本内容""" + # 提取可能的端点和配置 + endpoints = re.findall(r'https?://[^\s"\']+', script_content) + zones = re.findall(r'zone["\']?\s*[:=]\s*["\']?(\d+)', script_content) + + logger.info(f"🔍 脚本分析结果:") + logger.info(f" 发现端点: {len(endpoints)} 个") + logger.info(f" 发现区域: {zones}") + + def simulate_page_load(self): + """模拟页面加载""" + target_url = self.config["target_website"] + + try: + logger.info(f"🌐 模拟页面加载: {target_url}") + + # 页面加载前延迟 + pre_load_delay = random.uniform(1, 3) + time.sleep(pre_load_delay) + + # 设置referrer + referrers = [ + "https://www.google.com/search?q=free+games", + "https://www.google.com/search?q=online+games", + "https://www.bing.com/search?q=mobile+games", + "https://duckduckgo.com/?q=html5+games", + "https://www.reddit.com/r/WebGames/", + "direct" + ] + + referrer = random.choice(referrers) + if referrer != "direct": + self.session.headers.update({"Referer": referrer}) + + # 发起页面请求 + response = self.session.get(target_url, timeout=15) + + if response.status_code == 200: + logger.info(f"✅ 页面加载成功 ({response.status_code})") + + # 模拟页面解析时间 + parse_time = random.uniform(0.5, 1.5) + time.sleep(parse_time) + + return True + else: + logger.error(f"❌ 页面加载失败: {response.status_code}") + return False + + except Exception as e: + logger.error(f"❌ 页面加载异常: {e}") + return False + + def generate_ad_requests(self): + """生成广告请求""" + fingerprint = self.generate_device_fingerprint() + + # 为每种广告类型生成请求 + ad_requests = [] + + for ad_type, config in self.ad_types.items(): + if random.random() < config["weight"]: + request_data = { + "zone": config["zone"], + "type": ad_type, + "device_id": fingerprint["device_id"], + "session_id": fingerprint["session_id"], + "screen_width": fingerprint["screen_width"], + "screen_height": fingerprint["screen_height"], + "timezone": fingerprint["timezone"], + "language": fingerprint["language"], + "platform": fingerprint["platform"], + "timestamp": int(time.time()), + "referrer": self.session.headers.get("Referer", "direct"), + "user_agent": self.session.headers.get("User-Agent", ""), + "ip_country": "US" + } + + ad_requests.append(request_data) + + return ad_requests + + def send_impression_requests(self, ad_requests): + """发送展示请求""" + impression_count = 0 + + for request_data in ad_requests: + try: + # 构造展示请求 + impression_url = f"https://{self.sw_domain}/impression" + + # 添加MonetTag特有的参数 + params = { + "zone": request_data["zone"], + "type": request_data["type"], + "device": request_data["device_id"], + "session": request_data["session_id"], + "sw": request_data["screen_width"], + "sh": request_data["screen_height"], + "tz": request_data["timezone"], + "lang": request_data["language"], + "platform": request_data["platform"], + "ts": request_data["timestamp"], + "ref": base64.b64encode(request_data["referrer"].encode()).decode(), + "ua": base64.b64encode(request_data["user_agent"].encode()).decode(), + "country": "US", + "r": random.random() + } + + # 发送请求 + response = self.session.get( + impression_url, + params=params, + timeout=self.request_config["timeout"] + ) + + if response.status_code in [200, 204]: + impression_count += 1 + logger.info(f"📊 展示请求成功: {request_data['type']} (Zone: {request_data['zone']})") + else: + logger.warning(f"⚠️ 展示请求失败: {response.status_code}") + + # 请求间隔 + time.sleep(random.uniform(0.1, 0.5)) + + except Exception as e: + logger.error(f"❌ 展示请求异常: {e}") + self.stats["errors"] += 1 + continue + + self.stats["impressions"] += impression_count + logger.info(f"📊 本次展示量: {impression_count}") + return impression_count + + def send_click_requests(self, ad_requests): + """发送点击请求""" + click_count = 0 + target_click_rate = self.config["settings"]["click_rate"] + + for request_data in ad_requests: + # 根据广告类型和设置的点击率决定是否点击 + ad_config = self.ad_types.get(request_data["type"], {}) + base_click_rate = ad_config.get("click_rate", 0.1) + + # 综合考虑全局点击率和广告类型点击率 + final_click_rate = (target_click_rate + base_click_rate) / 2 + + if random.random() < final_click_rate: + try: + # 模拟用户思考时间 + think_time = random.uniform(1, 4) + time.sleep(think_time) + + # 构造点击请求 + click_url = f"https://{self.sw_domain}/click" + + # 点击请求参数 + click_params = { + "zone": request_data["zone"], + "type": request_data["type"], + "device": request_data["device_id"], + "session": request_data["session_id"], + "click_id": hashlib.md5(str(time.time()).encode()).hexdigest(), + "timestamp": int(time.time()), + "x": random.randint(10, 200), + "y": random.randint(10, 300), + "country": "US", + "r": random.random() + } + + # 发送点击请求 + response = self.session.post( + click_url, + data=click_params, + timeout=self.request_config["timeout"] + ) + + if response.status_code in [200, 201, 204]: + click_count += 1 + logger.info(f"🖱️ 点击请求成功: {request_data['type']} (Zone: {request_data['zone']})") + + # 模拟点击后行为 + self._simulate_post_click_behavior(request_data) + + else: + logger.warning(f"⚠️ 点击请求失败: {response.status_code}") + + except Exception as e: + logger.error(f"❌ 点击请求异常: {e}") + self.stats["errors"] += 1 + continue + + self.stats["clicks"] += click_count + logger.info(f"🖱️ 本次点击量: {click_count}") + return click_count + + def _simulate_post_click_behavior(self, request_data): + """模拟点击后行为""" + # 模拟广告页面停留时间 + stay_time = random.uniform(2, 8) + + # 根据广告类型调整行为 + if request_data["type"] == "onclick_popunder": + # 弹窗广告，用户可能快速关闭 + if random.random() < 0.7: + stay_time = random.uniform(0.5, 2) + logger.info(f" 🚫 快速关闭弹窗: {stay_time:.1f}秒") + elif request_data["type"] == "native_banner": + # 原生广告，用户可能更感兴趣 + if random.random() < 0.4: + stay_time = random.uniform(5, 15) + logger.info(f" 📖 阅读原生广告: {stay_time:.1f}秒") + + time.sleep(stay_time) + + def run_single_session(self): + """运行单次会话""" + logger.info("🚀 开始单次MonetTag刷量会话") + + # 设置会话 + self.setup_session() + + try: + # 1. 加载标签脚本 + if not self.load_tag_script(): + logger.error("❌ 标签脚本加载失败") + return False + + # 2. 模拟页面加载 + if not self.simulate_page_load(): + logger.error("❌ 页面加载失败") + return False + + # 3. 生成广告请求 + ad_requests = self.generate_ad_requests() + if not ad_requests: + logger.warning("⚠️ 未生成广告请求") + return False + + logger.info(f"🎯 生成了 {len(ad_requests)} 个广告请求") + + # 4. 发送展示请求 + impression_count = self.send_impression_requests(ad_requests) + + # 5. 发送点击请求 + click_count = self.send_click_requests(ad_requests) + + # 6. 更新统计 + self.stats["total_visits"] += 1 + if impression_count > 0: + self.stats["click_rate"] = self.stats["clicks"] / self.stats["impressions"] + + logger.info(f"✅ 会话完成: 展示={impression_count}, 点击={click_count}") + return True + + except Exception as e: + logger.error(f"❌ 会话执行异常: {e}") + self.stats["errors"] += 1 + return False + finally: + if self.session: + self.session.close() + + def run_continuous_sessions(self, total_sessions=None, delay_range=None): + """运行连续会话""" + if total_sessions is None: + total_sessions = self.config['settings'].get('visits_per_hour', 100) + + if delay_range is None: + delay_range = ( + self.config['settings']['min_delay'], + self.config['settings']['max_delay'] + ) + + success_count = 0 + + logger.info(f"🎯 开始连续MonetTag刷量，目标: {total_sessions} 次") + logger.info(f"📊 目标点击率: {self.config['settings']['click_rate']*100}%") + logger.info(f"🇺🇸 主要地区: 美国") + logger.info(f"📱 主要设备: 手机端 ({self.config['settings']['mobile_rate']*100}%)") + + for i in range(total_sessions): + logger.info(f"{'='*60}") + logger.info(f"🔄 第 {i+1}/{total_sessions} 次会话") + logger.info(f"{'='*60}") + + session_start = time.time() + + if self.run_single_session(): + success_count += 1 + session_time = time.time() - session_start + + # 实时统计 + current_click_rate = (self.stats["clicks"] / max(self.stats["impressions"], 1)) * 100 + + logger.info(f"✅ 第 {i+1} 次会话成功！耗时: {session_time:.1f}秒") + logger.info(f"📊 累计统计: 访问={self.stats['total_visits']}, 展示={self.stats['impressions']}, 点击={self.stats['clicks']}, 点击率={current_click_rate:.1f}%") + else: + logger.error(f"❌ 第 {i+1} 次会话失败！") + + # 会话间隔 + if i < total_sessions - 1: + delay = random.uniform(delay_range[0], delay_range[1]) + logger.info(f"⏳ 等待 {delay:.1f} 秒") + time.sleep(delay) + + # 最终统计 + self._print_final_stats(success_count, total_sessions) + + return success_count + + def _print_final_stats(self, success_count, total_sessions): + """打印最终统计""" + success_rate = (success_count / total_sessions) * 100 + click_rate = (self.stats["clicks"] / max(self.stats["impressions"], 1)) * 100 + + logger.info(f"🎉 MonetTag刷量任务完成！") + logger.info(f"📊 最终统计:") + logger.info(f" 成功率: {success_count}/{total_sessions} ({success_rate:.1f}%)") + logger.info(f" 总访问: {self.stats['total_visits']}") + logger.info(f" 总展示: {self.stats['impressions']}") + logger.info(f" 总点击: {self.stats['clicks']}") + logger.info(f" 点击率: {click_rate:.1f}%") + logger.info(f" 错误数: {self.stats['errors']}") + logger.info(f" 🎯 Zone ID: {self.zone_id}") + logger.info(f" 🇺🇸 主要地区: 美国") + logger.info(f" 📱 主要设备: 手机端") + +def main(): + """主函数""" + print("=" * 80) + print("🎯 MonetTag 专用刷量机器人") + print("=" * 80) + print("💡 核心特性:") + print(" 🎯 MonetTag Zone: 157708") + print(" 📊 点击率控制: 10%") + print(" 🇺🇸 主要地区: 美国") + print(" 📱 主要设备: 手机端 (90%)") + print(" 🔄 支持广告类型: Push, Banner, Native, Popunder") + print() + + try: + bot = MonetTagBot() + + print("请选择运行模式:") + print("1. 🧪 单次会话测试") + print("2. 🚀 连续会话 (使用配置参数)") + print("3. ⚙️ 自定义连续会话") + + choice = input("请输入选择 (1/2/3): ").strip() + + if choice == "1": + logger.info("🧪 开始单次会话测试") + success = bot.run_single_session() + if success: + print("🎉 单次会话测试成功！") + else: + print("😞 单次会话测试失败！") + + elif choice == "2": + logger.info("🚀 开始连续会话") + success_count = bot.run_continuous_sessions() + print(f"🎉 连续会话完成！成功: {success_count}") + + elif choice == "3": + try: + session_count = int(input("请输入会话次数: ").strip()) + min_delay = int(input("请输入最小延迟秒数: ").strip()) + max_delay = int(input("请输入最大延迟秒数: ").strip()) + + logger.info(f"🚀 开始自定义会话，次数: {session_count}") + success_count = bot.run_continuous_sessions( + total_sessions=session_count, + delay_range=(min_delay, max_delay) + ) + + print(f"🎉 自定义会话完成！成功: {success_count}/{session_count}") + + except ValueError: + print("❌ 输入参数错误！") + else: + print("❌ 无效选择！") + + except KeyboardInterrupt: + print("\n⚠️ 用户中断执行") + except Exception as e: + logger.error(f"程序执行出错: {e}") + print("❌ 程序执行出错，请查看日志文件 monetag_bot.log") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/monetag_config.json b/monetag_config.json new file mode 100644 index 0000000..e8357b1 --- /dev/null +++ b/monetag_config.json @@ -0,0 +1,58 @@ +{ + "target_website": "https://your-website.com", + "proxy": { + "enabled": false, + "host": "us-proxy.example.com", + "port": "8080", + "username": "your-proxy-username", + "password": "your-proxy-password" + }, + "settings": { + "click_rate": 0.10, + "mobile_rate": 0.90, + "us_traffic_rate": 1.0, + "visits_per_hour": 100, + "min_delay": 30, + "max_delay": 90 + }, + "monetag": { + "zone_id": "157708", + "base_domain": "fpyf8.com", + "sw_domain": "aiharsoreersu.net", + "ad_types": { + "push_notifications": { + "enabled": true, + "weight": 0.2, + "click_rate": 0.12 + }, + "vignette_banner": { + "enabled": true, + "weight": 0.25, + "click_rate": 0.08 + }, + "native_banner": { + "enabled": true, + "weight": 0.2, + "click_rate": 0.15 + }, + "in_page_push": { + "enabled": true, + "weight": 0.2, + "click_rate": 0.10 + }, + "onclick_popunder": { + "enabled": true, + "weight": 0.15, + "click_rate": 0.05 + } + } + }, + "advanced": { + "request_timeout": 10, + "max_retries": 3, + "retry_delay": 2, + "user_agent_rotation": true, + "device_fingerprinting": true, + "real_browser_headers": true + } +} \ No newline at end of file diff --git a/run_monetag_bot.bat b/run_monetag_bot.bat new file mode 100644 index 0000000..54c628e --- /dev/null +++ b/run_monetag_bot.bat @@ -0,0 +1,80 @@ +@echo off +chcp 65001 >nul +title MonetTag 专用刷量机器人 + +echo =============================================================== +echo 🎯 MonetTag 专用刷量机器人 +echo =============================================================== +echo 💡 核心特性: +echo 🎯 MonetTag Zone: 157708 +echo 📊 点击率控制: 10% +echo 🇺🇸 主要地区: 美国 +echo 📱 主要设备: 手机端 (90%) +echo 🔄 支持广告类型: Push, Banner, Native, Popunder +echo 💰 展示量 + 点击量双重刷量 +echo. + +:: 检查Python +python --version >nul 2>&1 +if %errorlevel% neq 0 ( + echo ❌ Python未安装！请先安装Python 3.7+ + pause + exit /b 1 +) + +echo ✅ Python已安装 +python --version + +:: 检查必要文件 +if not exist monetag_config.json ( + echo ❌ 配置文件 monetag_config.json 不存在！ + pause + exit /b 1 +) + +if not exist monetag_bot.py ( + echo ❌ MonetTag机器人文件 monetag_bot.py 不存在！ + pause + exit /b 1 +) + +echo ✅ 所有文件检查完成 + +:: 安装依赖 +echo. +echo 📦 检查并安装依赖... +pip install requests --quiet +if %errorlevel% neq 0 ( + echo ❌ 依赖安装失败！ + pause + exit /b 1 +) +echo ✅ 依赖安装成功 + +echo. +echo 🎯 MonetTag 刷量特性： +echo 📊 Zone ID: 157708 +echo 🇺🇸 美国IP代理: 支持 +echo 📱 手机端用户: 90%概率 +echo 🎭 真实用户行为: 完全模拟 +echo 📈 展示量统计: 实时追踪 +echo 🖱️ 点击量控制: 10%点击率 +echo 🔄 5种广告类型: Push、Banner、Native、Popunder、In-Page +echo ⏱️ 智能延迟: 30-90秒间隔 +echo 📊 详细统计: 成功率、点击率、错误率 +echo. + +echo 🚀 启动MonetTag刷量机器人... +python monetag_bot.py + +echo. +echo 🏁 MonetTag刷量任务完成！ +echo 📝 详细日志请查看 monetag_bot.log 文件 +echo 💡 MonetTag专用特点： +echo - 针对Zone 157708优化 +echo - 美国流量为主 +echo - 手机端设备特征 +echo - 10%精准点击率控制 +echo - 展示量和点击量双重刷量 +echo - 支持代理IP配置 +pause \ No newline at end of file diff --git a/run_universal_ad_bot.bat b/run_universal_ad_bot.bat deleted file mode 100644 index 21dce0c..0000000 --- a/run_universal_ad_bot.bat +++ /dev/null @@ -1,83 +0,0 @@ -@echo off -chcp 65001 >nul -title 通用广告刷量机器人 - 智能识别版 - -echo =============================================================== -echo 🎯 通用广告刷量机器人 (智能识别版) -echo =============================================================== -echo 💡 核心特性: -echo 🔍 智能广告识别 - 自动检测各种广告类型 -echo 🎭 真实用户行为 - 75%概率讨厌广告 -echo ❌ 智能关闭按钮 - 自动寻找并点击关闭按钮 -echo 📱 移动端优先 - 85%概率使用移动设备 -echo 🌐 通用适配 - 适用于任何广告网络 -echo 📊 详细统计 - 检测率、关闭率、点击率 -echo ⚠️ 请确保仅用于测试自己的网站！ -echo. - -:: 检查Python -python --version >nul 2>&1 -if %errorlevel% neq 0 ( - echo ❌ Python未安装！请先安装Python 3.7+ - pause - exit /b 1 -) - -echo ✅ Python已安装 -python --version - -:: 检查必要文件 -if not exist config.json ( - echo ❌ 配置文件 config.json 不存在！ - pause - exit /b 1 -) - -if not exist real_user_database.py ( - echo ❌ 用户数据库文件 real_user_database.py 不存在！ - pause - exit /b 1 -) - -if not exist universal_ad_bot.py ( - echo ❌ 通用广告机器人文件 universal_ad_bot.py 不存在！ - pause - exit /b 1 -) - -echo ✅ 所有文件检查完成 - -:: 安装依赖 -echo. -echo 📦 检查并安装依赖... -pip install requests --quiet -if %errorlevel% neq 0 ( - echo ❌ 依赖安装失败！ - pause - exit /b 1 -) -echo ✅ 依赖安装成功 - -echo. -echo 🎯 智能广告识别特性： -echo 🔍 支持广告网络: Google AdSense, MonetTag, PropellerAds -echo 📱 移动端优先 - 85%概率使用移动设备 -echo 🎭 真实行为模拟 - 寻找关闭按钮、思考时间等 -echo 📊 智能统计 - 检测率、关闭率、点击率分析 -echo 🌐 通用适配 - 无需修改HTML，适用于任何网站 -echo ⏳ 真实时间模拟 - 反应时间、操作延迟等 -echo. - -echo 🚀 启动通用广告刷量机器人... -python universal_ad_bot.py - -echo. -echo 🏁 通用广告刷量任务完成！ -echo 📝 详细日志请查看 universal_ad_bot.log 文件 -echo 💡 智能识别特点： -echo - 自动检测各种广告网络和类型 -echo - 75%的用户讨厌广告并选择关闭 -echo - 智能识别关闭按钮并模拟点击 -echo - 适用于任何使用智能合一广告的网站 -echo - 无需修改现有HTML结构 -pause \ No newline at end of file diff --git a/universal_ad_bot.py b/universal_ad_bot.py deleted file mode 100644 index c6ed205..0000000 --- a/universal_ad_bot.py +++ /dev/null @@ -1,1189 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -通用广告刷量机器人 (智能识别版) -智能识别网页上的各种广告类型并模拟真实用户行为 -适用于任何使用智能合一广告系统的网站 -""" - -import requests -import time -import random -import json -import os -import logging -from urllib.parse import urlparse, urljoin -import re -from real_user_database import RealUserDatabase - -# 配置日志 -logging.basicConfig( - level=logging.INFO, - format='%(asctime)s - %(levelname)s - %(message)s', - handlers=[ - logging.FileHandler('universal_ad_bot.log', encoding='utf-8'), - logging.StreamHandler() - ] -) -logger = logging.getLogger(__name__) - -class UniversalAdBot: - def __init__(self, config_file='config.json'): - """ - 初始化通用广告机器人 - """ - self.config = self.load_config(config_file) - self.session = None - self.user_db = RealUserDatabase() - self.current_profile = None - self.current_behavior = None - - # 🎯 广告元素识别模式 - self.ad_selectors = { - # 通用广告容器 - "containers": [ - "div[class*='ad']", "div[id*='ad']", "div[class*='banner']", - "div[class*='popup']", "div[class*='modal']", "div[class*='overlay']", - "div[class*='interstitial']", "div[class*='native']", "div[class*='sponsor']", - "iframe[src*='ads']", "iframe[src*='doubleclick']", "iframe[src*='googlesyndication']", - "ins[class*='adsbygoogle']", "[data-ad-client]", "[data-ad-slot]" - ], - # 关闭按钮模式 - "close_buttons": [ - "button[class*='close']", "span[class*='close']", "div[class*='close']", - "a[class*='close']", "i[class*='close']", "[aria-label*='close']", - "[title*='close']", "[alt*='close']", "button[type='button']", - ".close", ".btn-close", ".modal-close", ".popup-close", - "span:contains('×')", "span:contains('✕')", "span:contains('Close')" - ], - # 广告点击区域 - "clickable_areas": [ - "a[href*='ads']", "a[href*='click']", "a[href*='redirect']", - "button[onclick*='ad']", "div[onclick*='ad']", "[data-click]", - "img[src*='ad']", "video[src*='ad']", "[data-ad-click]" - ] - } - - # 🎯 广告行为概率配置 - self.ad_behaviors = { - "popup_modal": { - "close_probability": 0.80, # 80%概率关闭弹窗 - "click_probability": 0.12, # 12%概率点击 - "ignore_probability": 0.08, # 8%概率忽略 - "annoyance_level": 0.9 # 高讨厌程度 - }, - "banner_display": { - "close_probability": 0.85, # 85%概率关闭横幅 - "click_probability": 0.10, # 10%概率点击 - "ignore_probability": 0.05, # 5%概率忽略 - "annoyance_level": 0.8 # 高讨厌程度 - }, - "native_content": { - "close_probability": 0.45, # 45%概率关闭原生广告 - "click_probability": 0.35, # 35%概率点击 - "read_probability": 0.20, # 20%概率阅读 - "annoyance_level": 0.3 # 低讨厌程度 - }, - "video_preroll": { - "skip_probability": 0.70, # 70%概率跳过视频广告 - "watch_probability": 0.20, # 20%概率观看 - "click_probability": 0.10, # 10%概率点击 - "annoyance_level": 0.7 # 较高讨厌程度 - }, - "interstitial_fullscreen": { - "close_probability": 0.65, # 65%概率关闭全屏广告 - "click_probability": 0.20, # 20%概率点击 - "wait_probability": 0.15, # 15%概率等待 - "annoyance_level": 0.6 # 中等讨厌程度 - } - } - - # 🎮 游戏列表 - self.games_list = [ - {"name": "2048", "url": "/games/2048/index.html", "category": "puzzle"}, - {"name": "Snake", "url": "/games/snake/index.html", "category": "arcade"}, - {"name": "DIY Doll Factory", "url": "/games/iframe-games.html?game=diy-doll-factory", "category": "puzzle"}, - {"name": "Super Sprunki Adventure", "url": "/games/iframe-games.html?game=super-sprunki-adventure", "category": "action"}, - {"name": "FlightBird", "url": "/games/iframe-games.html?game=flightbird", "category": "action"}, - ] - - # 🎯 真实的访问来源 - self.traffic_sources = [ - "https://www.google.com/search?q=free+online+games", - "https://www.google.com/search?q=2048+game+online", - "https://www.google.com/search?q=html5+games+mobile", - "https://www.google.com/search?q=在线小游戏", - "https://www.google.com/search?q=免费网页游戏", - "https://www.baidu.com/s?wd=2048数字游戏", - "https://www.reddit.com/r/WebGames/", - "https://github.com/topics/html5-game", - "https://news.ycombinator.com/", - ] - - # 📊 访问统计 - self.visit_stats = { - "total_visits": 0, - "ad_interactions": { - "detected_ads": 0, - "close_button_clicks": 0, - "ad_content_clicks": 0, - "skip_actions": 0, - "ignored_ads": 0 - }, - "ad_types_found": {}, - "total_ad_time": 0, - "detection_success_rate": 0 - } - - def load_config(self, config_file): - """加载配置文件""" - try: - with open(config_file, 'r', encoding='utf-8') as f: - config = json.load(f) - logger.info(f"配置文件加载成功: {config_file}") - return config - except FileNotFoundError: - logger.error(f"配置文件未找到: {config_file}") - raise - except json.JSONDecodeError as e: - logger.error(f"配置文件格式错误: {e}") - raise - - def setup_session(self): - """设置请求会话""" - self.session = requests.Session() - self.session.cookies.clear() - - # 生成真实用户配置 - self.current_profile = self.user_db.get_random_user_profile() - self.current_behavior = self.user_db.get_visit_behavior() - - # 设置代理 - proxy_config = self.config.get('proxy') - if proxy_config: - proxy_url = f"http://{proxy_config['username']}:{proxy_config['password']}@{proxy_config['host']}:{proxy_config['port']}" - self.session.proxies = { - 'http': proxy_url, - 'https': proxy_url - } - logger.info(f"已配置代理: {proxy_config['host']}:{proxy_config['port']}") - - # 🎯 真实用户代理 - 优先移动端 - if random.random() < 0.85: # 85%概率使用移动端 - mobile_agents = [ - "Mozilla/5.0 (iPhone; CPU iPhone OS 17_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1", - "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", - "Mozilla/5.0 (Linux; Android 14; SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36", - "Mozilla/5.0 (Linux; Android 13; SM-A515F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36", - "Mozilla/5.0 (iPad; CPU OS 17_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1", - ] - user_agent = random.choice(mobile_agents) - is_mobile = True - else: - user_agent = self.current_profile["user_agent"] - is_mobile = "Mobile" in user_agent - - # 广告友好的请求头 - headers = { - "User-Agent": user_agent, - "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - "Accept-Encoding": "gzip, deflate, br", - "Connection": "keep-alive", - "Upgrade-Insecure-Requests": "1", - "Sec-Fetch-Dest": "document", - "Sec-Fetch-Mode": "navigate", - "Sec-Fetch-Site": "none", - "Sec-Fetch-User": "?1", - "Cache-Control": "max-age=0", - "DNT": "0", # 不启用DNT，对广告友好 - } - - if is_mobile: - headers.update({ - "Sec-CH-UA-Mobile": "?1", - "Viewport-Width": str(random.choice([375, 414, 390, 393, 412])), - }) - - self.session.headers.update(headers) - - logger.info(f"🎭 通用广告机器人配置:") - logger.info(f" 📱 移动端: {is_mobile}") - logger.info(f" 🎯 访问模式: {self.current_behavior['pattern_type']}") - logger.info(f" 🔍 智能广告识别: 启用") - logger.info(f" 😤 用户讨厌广告概率: 75%") - - def simulate_traffic_source(self): - """模拟真实的访问来源""" - source = random.choice(self.traffic_sources) - - try: - logger.info(f"🔗 模拟从来源访问: {source}") - - # 根据来源类型设置不同的行为 - if "google.com" in source or "baidu.com" in source: - stay_time = random.uniform(2, 8) - logger.info(f"🔍 搜索引擎停留: {stay_time:.1f}秒") - elif "reddit.com" in source: - stay_time = random.uniform(8, 20) - logger.info(f"🔍 Reddit停留: {stay_time:.1f}秒") - elif "github.com" in source: - stay_time = random.uniform(5, 15) - logger.info(f"🔍 GitHub停留: {stay_time:.1f}秒") - else: - stay_time = random.uniform(3, 12) - logger.info(f"🔍 其他来源停留: {stay_time:.1f}秒") - - # 模拟来源网站行为 - self._simulate_source_behavior(stay_time) - - # 设置referrer - self.session.headers.update({ - 'Referer': source, - 'Sec-Fetch-Site': 'cross-site' - }) - - return True - - except Exception as e: - logger.error(f"来源访问模拟失败: {e}") - return False - - def _simulate_source_behavior(self, total_time): - """模拟在来源网站的行为""" - actions = ["浏览搜索结果", "阅读页面内容", "查看相关链接", "滚动浏览页面"] - segments = random.randint(2, 4) - segment_time = total_time / segments - - for i in range(segments): - if i > 0: - time.sleep(random.uniform(0.5, 2)) - - action = random.choice(actions) - logger.info(f" 🔍 {action}") - time.sleep(segment_time * random.uniform(0.7, 1.3)) - - def visit_homepage_with_universal_ads(self): - """访问首页并智能识别处理广告""" - main_site = self.config['targets']['main_site'] - - try: - logger.info(f"🏠 访问首页并智能识别广告: {main_site}") - - # 访问前延迟 - pre_delay = random.uniform(2, 5) - logger.info(f"🕐 访问前延迟: {pre_delay:.1f}秒") - time.sleep(pre_delay) - - # 发起请求 - response = self.session.get(main_site, timeout=20, allow_redirects=True) - - if response.status_code == 200: - logger.info(f"✅ 首页访问成功 ({response.status_code})") - logger.info(f"📦 页面大小: {len(response.content)} 字节") - - # 🎯 核心：智能识别和处理广告 - self._intelligent_ad_detection_and_interaction(response) - - return True - else: - logger.error(f"❌ 首页访问失败 ({response.status_code})") - return False - - except Exception as e: - logger.error(f"首页访问出错: {e}") - return False - - def _intelligent_ad_detection_and_interaction(self, response): - """智能识别和处理广告""" - base_url = response.url - page_content = response.text - - # 首页总停留时间 - homepage_stay_time = random.uniform(25, 60) - logger.info(f"🏠 首页总停留时间: {homepage_stay_time:.1f}秒") - - # 🔍 智能检测页面上的广告 - detected_ads = self._detect_ads_in_page(page_content) - - if detected_ads: - logger.info(f"🎯 智能检测到 {len(detected_ads)} 个广告元素") - self.visit_stats["ad_interactions"]["detected_ads"] += len(detected_ads) - - # 分阶段处理检测到的广告 - self._process_detected_ads(base_url, detected_ads, homepage_stay_time) - else: - logger.info("🔍 未检测到明显的广告元素，进行通用广告行为模拟") - self._simulate_generic_ad_behavior(base_url, homepage_stay_time) - - # 📊 输出检测和交互统计 - self._log_universal_ad_stats() - - def _detect_ads_in_page(self, page_content): - """在页面内容中检测广告""" - detected_ads = [] - - # 检测广告脚本标签 - ad_scripts = [ - r'googlesyndication\.com', - r'doubleclick\.net', - r'googletagmanager\.com', - r'facebook\.com/tr', - r'monetag', - r'adnxs\.com', - r'adsystem\.com', - r'amazon-adsystem\.com', - r'ads\.yahoo\.com', - r'media\.net', - r'popads\.net', - r'propellerads\.com', - r'adsterra\.com', - r'exoclick\.com', - r'clickadu\.com', - r'hilltopads\.com', - r'theprofitzone\.com', - r'revcontent\.com', - r'outbrain\.com', - r'taboola\.com', - r'mgid\.com' - ] - - for script_pattern in ad_scripts: - matches = re.findall(script_pattern, page_content, re.IGNORECASE) - if matches: - ad_type = self._classify_ad_type(script_pattern) - detected_ads.append({ - "type": ad_type, - "source": script_pattern, - "count": len(matches) - }) - logger.info(f" 🔍 检测到 {ad_type} 广告: {len(matches)} 个") - - # 检测广告HTML元素 - ad_elements = [ - r']*class="[^"]*ad[^"]*"[^>]*>', - r']*id="[^"]*ad[^"]*"[^>]*>', - r']*class="[^"]*adsbygoogle[^"]*"[^>]*>', - r']*src="[^"]*ads[^"]*"[^>]*>', - r']*class="[^"]*banner[^"]*"[^>]*>', - r']*class="[^"]*popup[^"]*"[^>]*>', - r']*class="[^"]*modal[^"]*"[^>]*>', - r']*class="[^"]*overlay[^"]*"[^>]*>', - r']*class="[^"]*interstitial[^"]*"[^>]*>', - r']*class="[^"]*native[^"]*"[^>]*>', - r']*class="[^"]*sponsor[^"]*"[^>]*>', - r'data-ad-client="[^"]*"', - r'data-ad-slot="[^"]*"' - ] - - for element_pattern in ad_elements: - matches = re.findall(element_pattern, page_content, re.IGNORECASE) - if matches: - ad_type = self._classify_ad_element_type(element_pattern) - detected_ads.append({ - "type": ad_type, - "source": "html_element", - "count": len(matches) - }) - logger.info(f" 🔍 检测到 {ad_type} 元素: {len(matches)} 个") - - return detected_ads - - def _classify_ad_type(self, script_pattern): - """根据脚本模式分类广告类型""" - type_mapping = { - "googlesyndication": "Google AdSense", - "doubleclick": "Google DoubleClick", - "googletagmanager": "Google Tag Manager", - "facebook": "Facebook Pixel", - "monetag": "MonetTag", - "amazon-adsystem": "Amazon Associates", - "popads": "PopAds", - "propellerads": "PropellerAds", - "adsterra": "Adsterra", - "exoclick": "ExoClick", - "clickadu": "ClickAdu", - "hilltopads": "HilltopAds", - "revcontent": "RevContent", - "outbrain": "Outbrain", - "taboola": "Taboola", - "mgid": "MGID" - } - - for key, value in type_mapping.items(): - if key in script_pattern: - return value - - return "Unknown Ad Network" - - def _classify_ad_element_type(self, element_pattern): - """根据元素模式分类广告类型""" - if "banner" in element_pattern: - return "banner_display" - elif "popup" in element_pattern or "modal" in element_pattern or "overlay" in element_pattern: - return "popup_modal" - elif "interstitial" in element_pattern: - return "interstitial_fullscreen" - elif "native" in element_pattern or "sponsor" in element_pattern: - return "native_content" - elif "adsbygoogle" in element_pattern or "data-ad" in element_pattern: - return "google_adsense" - else: - return "generic_ad" - - def _process_detected_ads(self, base_url, detected_ads, total_time): - """处理检测到的广告""" - logger.info(f"📺 开始处理检测到的广告") - - # 为每个广告分配处理时间 - ad_count = len(detected_ads) - time_per_ad = total_time / max(ad_count, 1) - - for i, ad in enumerate(detected_ads): - ad_type = ad["type"] - ad_count = ad["count"] - - logger.info(f"🎯 处理广告 {i+1}/{len(detected_ads)}: {ad_type} ({ad_count}个)") - - # 根据广告类型选择处理策略 - if ad_type in ["popup_modal", "interstitial_fullscreen"]: - self._handle_popup_interstitial_ads(base_url, ad_type, time_per_ad) - elif ad_type in ["banner_display", "google_adsense"]: - self._handle_banner_display_ads(base_url, ad_type, time_per_ad) - elif ad_type in ["native_content"]: - self._handle_native_content_ads(base_url, ad_type, time_per_ad) - else: - self._handle_generic_ads(base_url, ad_type, time_per_ad) - - # 更新统计 - if ad_type not in self.visit_stats["ad_types_found"]: - self.visit_stats["ad_types_found"][ad_type] = 0 - self.visit_stats["ad_types_found"][ad_type] += ad_count - - def _handle_popup_interstitial_ads(self, base_url, ad_type, allocated_time): - """处理弹窗和插页广告""" - logger.info(f" 📺 处理弹窗/插页广告: {ad_type}") - - # 模拟广告显示延迟 - display_delay = random.uniform(1, 4) - logger.info(f" 🔄 广告显示延迟: {display_delay:.1f}秒") - time.sleep(display_delay) - - # 模拟用户反应 - reaction_time = random.uniform(0.5, 2) - logger.info(f" 👀 用户反应时间: {reaction_time:.1f}秒") - time.sleep(reaction_time) - - # 决定用户行为 - behavior = self.ad_behaviors.get("popup_modal", self.ad_behaviors["popup_modal"]) - user_action = self._decide_user_action_for_ad(behavior) - - # 执行行为 - if user_action == "close": - self._simulate_close_popup(base_url, ad_type) - elif user_action == "click": - self._simulate_click_popup(base_url, ad_type) - else: - self._simulate_ignore_popup(base_url, ad_type) - - def _handle_banner_display_ads(self, base_url, ad_type, allocated_time): - """处理横幅显示广告""" - logger.info(f" 📺 处理横幅广告: {ad_type}") - - # 模拟广告加载 - load_time = random.uniform(0.5, 2) - logger.info(f" 📥 广告加载时间: {load_time:.1f}秒") - time.sleep(load_time) - - # 模拟用户浏览时注意到广告 - notice_time = random.uniform(2, 6) - logger.info(f" 👁️ 用户注意到广告: {notice_time:.1f}秒") - time.sleep(notice_time) - - # 决定用户行为 - behavior = self.ad_behaviors.get("banner_display", self.ad_behaviors["banner_display"]) - user_action = self._decide_user_action_for_ad(behavior) - - # 执行行为 - if user_action == "close": - self._simulate_close_banner(base_url, ad_type) - elif user_action == "click": - self._simulate_click_banner(base_url, ad_type) - else: - self._simulate_ignore_banner(base_url, ad_type) - - def _handle_native_content_ads(self, base_url, ad_type, allocated_time): - """处理原生内容广告""" - logger.info(f" 📺 处理原生广告: {ad_type}") - - # 模拟用户阅读内容时发现广告 - read_time = random.uniform(3, 8) - logger.info(f" 📖 用户阅读发现广告: {read_time:.1f}秒") - time.sleep(read_time) - - # 决定用户行为 - behavior = self.ad_behaviors.get("native_content", self.ad_behaviors["native_content"]) - user_action = self._decide_user_action_for_ad(behavior) - - # 执行行为 - if user_action == "close": - self._simulate_close_native(base_url, ad_type) - elif user_action == "click": - self._simulate_click_native(base_url, ad_type) - elif user_action == "read": - self._simulate_read_native(base_url, ad_type) - else: - self._simulate_ignore_native(base_url, ad_type) - - def _handle_generic_ads(self, base_url, ad_type, allocated_time): - """处理通用广告""" - logger.info(f" 📺 处理通用广告: {ad_type}") - - # 模拟通用广告行为 - generic_time = random.uniform(2, 6) - logger.info(f" 🎯 通用广告交互: {generic_time:.1f}秒") - time.sleep(generic_time) - - # 随机决定行为 - if random.random() < 0.75: # 75%概率关闭 - self._simulate_close_generic(base_url, ad_type) - elif random.random() < 0.15: # 15%概率点击 - self._simulate_click_generic(base_url, ad_type) - else: # 10%概率忽略 - self._simulate_ignore_generic(base_url, ad_type) - - def _decide_user_action_for_ad(self, behavior): - """决定用户对广告的行为""" - # 考虑时间因素 - time_factor = self._get_time_tolerance_factor() - - # 调整概率 - close_prob = behavior["close_probability"] * time_factor - click_prob = behavior["click_probability"] - - # 随机决定 - rand = random.random() - - if rand < close_prob: - return "close" - elif rand < close_prob + click_prob: - return "click" - elif "read_probability" in behavior and rand < close_prob + click_prob + behavior["read_probability"]: - return "read" - else: - return "ignore" - - def _get_time_tolerance_factor(self): - """获取时间容忍度因子""" - current_hour = time.localtime().tm_hour - - if 9 <= current_hour <= 18: # 工作时间 - return 1.2 # 更讨厌广告 - elif 19 <= current_hour <= 23: # 休闲时间 - return 0.8 # 相对容忍 - else: # 深夜 - return 1.0 # 普通 - - def _simulate_close_popup(self, base_url, ad_type): - """模拟关闭弹窗广告""" - logger.info(f" ❌ 关闭弹窗广告") - - # 寻找关闭按钮 - find_time = random.uniform(0.5, 2) - logger.info(f" 🔍 寻找关闭按钮: {find_time:.1f}秒") - time.sleep(find_time) - - # 点击关闭 - click_time = random.uniform(0.2, 0.8) - logger.info(f" 🖱️ 点击关闭按钮") - time.sleep(click_time) - - # 发送关闭请求 - self._send_ad_interaction_request(base_url, ad_type, "close") - - # 更新统计 - self.visit_stats["ad_interactions"]["close_button_clicks"] += 1 - - # 关闭后释放 - relief_time = random.uniform(0.5, 1.5) - logger.info(f" 😌 关闭后释放: {relief_time:.1f}秒") - time.sleep(relief_time) - - def _simulate_click_popup(self, base_url, ad_type): - """模拟点击弹窗广告""" - logger.info(f" 🖱️ 点击弹窗广告") - - # 思考时间 - think_time = random.uniform(1, 3) - logger.info(f" 🤔 思考时间: {think_time:.1f}秒") - time.sleep(think_time) - - # 点击广告 - click_time = random.uniform(0.3, 1) - time.sleep(click_time) - - # 发送点击请求 - self._send_ad_interaction_request(base_url, ad_type, "click") - - # 更新统计 - self.visit_stats["ad_interactions"]["ad_content_clicks"] += 1 - - # 点击后可能返回 - if random.random() < 0.7: - return_time = random.uniform(1, 3) - logger.info(f" 🔙 快速返回: {return_time:.1f}秒") - time.sleep(return_time) - - def _simulate_ignore_popup(self, base_url, ad_type): - """模拟忽略弹窗广告""" - logger.info(f" 🙈 忽略弹窗广告") - - ignore_time = random.uniform(2, 5) - logger.info(f" 😐 忽略时间: {ignore_time:.1f}秒") - time.sleep(ignore_time) - - # 更新统计 - self.visit_stats["ad_interactions"]["ignored_ads"] += 1 - - def _simulate_close_banner(self, base_url, ad_type): - """模拟关闭横幅广告""" - logger.info(f" ❌ 关闭横幅广告") - - # 寻找关闭按钮 - find_time = random.uniform(0.3, 1.5) - logger.info(f" 🔍 寻找关闭按钮: {find_time:.1f}秒") - time.sleep(find_time) - - # 点击关闭 - click_time = random.uniform(0.2, 0.6) - logger.info(f" 🖱️ 点击关闭按钮") - time.sleep(click_time) - - # 发送关闭请求 - self._send_ad_interaction_request(base_url, ad_type, "close") - - # 更新统计 - self.visit_stats["ad_interactions"]["close_button_clicks"] += 1 - - def _simulate_click_banner(self, base_url, ad_type): - """模拟点击横幅广告""" - logger.info(f" 🖱️ 点击横幅广告") - - # 点击广告 - click_time = random.uniform(0.5, 1.5) - time.sleep(click_time) - - # 发送点击请求 - self._send_ad_interaction_request(base_url, ad_type, "click") - - # 更新统计 - self.visit_stats["ad_interactions"]["ad_content_clicks"] += 1 - - def _simulate_ignore_banner(self, base_url, ad_type): - """模拟忽略横幅广告""" - logger.info(f" 🙈 忽略横幅广告") - - ignore_time = random.uniform(1, 3) - time.sleep(ignore_time) - - # 更新统计 - self.visit_stats["ad_interactions"]["ignored_ads"] += 1 - - def _simulate_close_native(self, base_url, ad_type): - """模拟关闭原生广告""" - logger.info(f" ❌ 关闭原生广告") - - # 原生广告关闭按钮通常较小 - find_time = random.uniform(1, 3) - logger.info(f" 🔍 寻找关闭按钮: {find_time:.1f}秒") - time.sleep(find_time) - - # 点击关闭 - click_time = random.uniform(0.3, 1) - logger.info(f" 🖱️ 点击关闭按钮") - time.sleep(click_time) - - # 发送关闭请求 - self._send_ad_interaction_request(base_url, ad_type, "close") - - # 更新统计 - self.visit_stats["ad_interactions"]["close_button_clicks"] += 1 - - def _simulate_click_native(self, base_url, ad_type): - """模拟点击原生广告""" - logger.info(f" 🖱️ 点击原生广告") - - # 原生广告点击前通常会多思考 - think_time = random.uniform(3, 6) - logger.info(f" 🤔 思考时间: {think_time:.1f}秒") - time.sleep(think_time) - - # 点击广告 - click_time = random.uniform(0.5, 1.5) - time.sleep(click_time) - - # 发送点击请求 - self._send_ad_interaction_request(base_url, ad_type, "click") - - # 更新统计 - self.visit_stats["ad_interactions"]["ad_content_clicks"] += 1 - - def _simulate_read_native(self, base_url, ad_type): - """模拟阅读原生广告""" - logger.info(f" 📖 阅读原生广告") - - # 阅读时间 - read_time = random.uniform(5, 12) - logger.info(f" 📚 阅读时间: {read_time:.1f}秒") - time.sleep(read_time) - - # 阅读后可能点击 - if random.random() < 0.3: - self._simulate_click_native(base_url, ad_type) - - def _simulate_ignore_native(self, base_url, ad_type): - """模拟忽略原生广告""" - logger.info(f" 🙈 忽略原生广告") - - ignore_time = random.uniform(2, 4) - time.sleep(ignore_time) - - # 更新统计 - self.visit_stats["ad_interactions"]["ignored_ads"] += 1 - - def _simulate_close_generic(self, base_url, ad_type): - """模拟关闭通用广告""" - logger.info(f" ❌ 关闭通用广告") - - close_time = random.uniform(1, 3) - logger.info(f" 🖱️ 关闭操作: {close_time:.1f}秒") - time.sleep(close_time) - - # 发送关闭请求 - self._send_ad_interaction_request(base_url, ad_type, "close") - - # 更新统计 - self.visit_stats["ad_interactions"]["close_button_clicks"] += 1 - - def _simulate_click_generic(self, base_url, ad_type): - """模拟点击通用广告""" - logger.info(f" 🖱️ 点击通用广告") - - click_time = random.uniform(1, 2) - time.sleep(click_time) - - # 发送点击请求 - self._send_ad_interaction_request(base_url, ad_type, "click") - - # 更新统计 - self.visit_stats["ad_interactions"]["ad_content_clicks"] += 1 - - def _simulate_ignore_generic(self, base_url, ad_type): - """模拟忽略通用广告""" - logger.info(f" 🙈 忽略通用广告") - - ignore_time = random.uniform(2, 4) - time.sleep(ignore_time) - - # 更新统计 - self.visit_stats["ad_interactions"]["ignored_ads"] += 1 - - def _simulate_generic_ad_behavior(self, base_url, total_time): - """模拟通用广告行为（当未检测到具体广告时）""" - logger.info(f"🎯 执行通用广告行为模拟") - - # 模拟可能存在但未检测到的广告 - possible_ads = ["弹窗广告", "横幅广告", "原生广告", "视频广告"] - - segments = random.randint(2, 4) - segment_time = total_time / segments - - for i in range(segments): - ad_type = random.choice(possible_ads) - logger.info(f" 🎯 模拟 {ad_type} 行为") - - # 模拟广告加载和交互 - load_time = random.uniform(1, 3) - logger.info(f" 📥 广告加载: {load_time:.1f}秒") - time.sleep(load_time) - - # 模拟用户行为 - if random.random() < 0.75: # 75%概率关闭 - logger.info(f" ❌ 关闭{ad_type}") - self._send_ad_interaction_request(base_url, ad_type, "close") - self.visit_stats["ad_interactions"]["close_button_clicks"] += 1 - elif random.random() < 0.15: # 15%概率点击 - logger.info(f" 🖱️ 点击{ad_type}") - self._send_ad_interaction_request(base_url, ad_type, "click") - self.visit_stats["ad_interactions"]["ad_content_clicks"] += 1 - else: # 10%概率忽略 - logger.info(f" 🙈 忽略{ad_type}") - self.visit_stats["ad_interactions"]["ignored_ads"] += 1 - - # 行为间隔 - time.sleep(segment_time - load_time) - - def _send_ad_interaction_request(self, base_url, ad_type, action): - """发送广告交互请求""" - try: - # 模拟广告交互API请求 - endpoints = [ - f"/api/ads/{action}", - f"/ads/{action}", - f"/tracking/ad_{action}", - f"/analytics/ad_interaction", - f"/stats/ad_{action}" - ] - - endpoint = random.choice(endpoints) - parsed_url = urlparse(base_url) - request_url = f"{parsed_url.scheme}://{parsed_url.netloc}{endpoint}" - - headers = self.session.headers.copy() - headers.update({ - "X-Requested-With": "XMLHttpRequest", - "Content-Type": "application/json", - "Referer": base_url, - }) - - payload = { - "ad_type": ad_type, - "action": action, - "timestamp": int(time.time()), - "user_agent": self.session.headers.get("User-Agent", ""), - "page_url": base_url - } - - response = self.session.post(request_url, headers=headers, - json=payload, timeout=5) - - logger.info(f" 📤 广告交互请求: {endpoint} ({response.status_code})") - - except Exception as e: - logger.debug(f" ⚠️ 广告交互请求失败: {e}") - - def _log_universal_ad_stats(self): - """记录通用广告统计""" - logger.info("📊 智能广告检测和交互统计:") - logger.info(f" 🔍 检测到广告: {self.visit_stats['ad_interactions']['detected_ads']} 个") - logger.info(f" ❌ 关闭按钮点击: {self.visit_stats['ad_interactions']['close_button_clicks']} 次") - logger.info(f" 🖱️ 广告内容点击: {self.visit_stats['ad_interactions']['ad_content_clicks']} 次") - logger.info(f" 🙈 忽略广告: {self.visit_stats['ad_interactions']['ignored_ads']} 次") - - if self.visit_stats["ad_types_found"]: - logger.info(" 🎯 发现的广告类型:") - for ad_type, count in self.visit_stats["ad_types_found"].items(): - logger.info(f" - {ad_type}: {count} 个") - - def browse_games_with_ads(self): - """浏览游戏页面并处理广告""" - main_site = self.config['targets']['main_site'] - base_url = main_site.rstrip('/') - - games_to_browse = random.randint(2, 4) - selected_games = random.sample(self.games_list, min(games_to_browse, len(self.games_list))) - - logger.info(f"🎮 浏览 {games_to_browse} 个游戏页面") - - for i, game in enumerate(selected_games): - game_url = base_url + game["url"] - - try: - logger.info(f"🎯 游戏 {i+1}/{games_to_browse}: {game['name']}") - - # 设置referrer - if i == 0: - self.session.headers.update({'Referer': main_site}) - else: - prev_game_url = base_url + selected_games[i-1]["url"] - self.session.headers.update({'Referer': prev_game_url}) - - # 访问游戏页面 - response = self.session.get(game_url, timeout=15) - - if response.status_code == 200: - logger.info(f"✅ 游戏页面访问成功") - - # 智能检测和处理游戏页面广告 - self._handle_game_page_ads(response, game) - - else: - logger.warning(f"⚠️ 游戏页面访问失败 ({response.status_code})") - - # 页面间延迟 - if i < len(selected_games) - 1: - delay = random.uniform(3, 8) - logger.info(f" ⏳ 页面切换延迟: {delay:.1f}秒") - time.sleep(delay) - - except Exception as e: - logger.error(f"游戏页面访问出错: {e}") - continue - - return True - - def _handle_game_page_ads(self, response, game): - """处理游戏页面的广告""" - game_stay_time = random.uniform(30, 90) - logger.info(f" 🎮 游戏页面停留: {game_stay_time:.1f}秒") - - # 检测游戏页面广告 - detected_ads = self._detect_ads_in_page(response.text) - - if detected_ads: - logger.info(f" 🔍 游戏页面检测到 {len(detected_ads)} 个广告") - - # 模拟游戏前广告 - if random.random() < 0.8: # 80%概率有游戏前广告 - logger.info(f" 📺 游戏前广告处理") - if random.random() < 0.7: # 70%概率跳过 - logger.info(f" ⏭️ 跳过游戏前广告") - self.visit_stats["ad_interactions"]["close_button_clicks"] += 1 - time.sleep(random.uniform(1, 3)) - else: - logger.info(f" ✅ 观看游戏前广告") - time.sleep(random.uniform(5, 15)) - - # 模拟游戏过程 - self._simulate_game_play(game, game_stay_time * 0.6) - - # 模拟游戏中广告 - if random.random() < 0.6: # 60%概率有游戏中广告 - logger.info(f" 📺 游戏中广告处理") - if random.random() < 0.8: # 80%概率关闭 - logger.info(f" ❌ 关闭游戏中广告") - self.visit_stats["ad_interactions"]["close_button_clicks"] += 1 - time.sleep(random.uniform(1, 2)) - else: - time.sleep(random.uniform(3, 8)) - - # 模拟游戏结束广告 - if random.random() < 0.9: # 90%概率有结束广告 - logger.info(f" 📺 游戏结束广告处理") - if random.random() < 0.5: # 50%概率关闭 - logger.info(f" ❌ 关闭游戏结束广告") - self.visit_stats["ad_interactions"]["close_button_clicks"] += 1 - time.sleep(random.uniform(1, 2)) - elif random.random() < 0.3: # 30%概率点击 - logger.info(f" 🖱️ 点击游戏结束广告") - self.visit_stats["ad_interactions"]["ad_content_clicks"] += 1 - time.sleep(random.uniform(2, 5)) - else: - logger.info(f" ✅ 观看游戏结束广告") - time.sleep(random.uniform(5, 15)) - else: - # 没有检测到广告，正常游戏 - logger.info(f" 🎮 正常游戏，未检测到广告") - self._simulate_game_play(game, game_stay_time) - - def _simulate_game_play(self, game, duration): - """模拟游戏过程""" - logger.info(f" 🎮 开始游戏: {game['name']}") - - # 根据游戏类型模拟不同行为 - if game["category"] == "puzzle": - actions = ["思考", "移动", "尝试", "撤销"] - segments = random.randint(4, 8) - elif game["category"] == "arcade": - actions = ["开始", "快速操作", "躲避", "收集"] - segments = random.randint(6, 12) - else: - actions = ["开始", "操作", "进行", "暂停"] - segments = random.randint(3, 6) - - segment_time = duration / segments - - for i in range(segments): - action = random.choice(actions) - logger.info(f" 🎯 {action}") - time.sleep(segment_time * random.uniform(0.8, 1.2)) - - def run_universal_ad_visit(self): - """执行通用广告访问流程""" - logger.info("🚀 开始通用广告访问流程") - - # 设置会话 - self.setup_session() - - try: - # 1. 模拟来源访问 - if not self.simulate_traffic_source(): - logger.warning("⚠️ 来源访问失败，继续执行") - - # 2. 访问首页并智能处理广告 - if not self.visit_homepage_with_universal_ads(): - logger.error("❌ 首页广告访问失败") - return False - - # 3. 浏览游戏页面 - if not self.browse_games_with_ads(): - logger.error("❌ 游戏页面访问失败") - return False - - # 更新统计 - self.visit_stats["total_visits"] += 1 - - logger.info("✅ 通用广告访问流程完成！") - return True - - except Exception as e: - logger.error(f"❌ 访问流程出错: {e}") - return False - - finally: - if self.session: - self.session.close() - - def run_continuous_universal_visits(self, total_visits=None, delay_range=None): - """连续执行通用广告访问""" - if total_visits is None: - total_visits = self.config['settings']['default_visits'] - - if delay_range is None: - delay_range = ( - self.config['settings']['min_delay'], - self.config['settings']['max_delay'] - ) - - success_count = 0 - - logger.info(f"🎯 开始连续通用广告访问，目标: {total_visits} 次") - - for i in range(total_visits): - logger.info(f"{'='*70}") - logger.info(f"🔄 第 {i+1}/{total_visits} 次通用广告访问") - logger.info(f"{'='*70}") - - visit_start_time = time.time() - - if self.run_universal_ad_visit(): - success_count += 1 - visit_time = time.time() - visit_start_time - - logger.info(f"✅ 第 {i+1} 次访问成功！耗时: {visit_time:.1f}秒") - - # 显示累计统计 - logger.info(f"📊 累计: 成功{success_count}, 检测广告{self.visit_stats['ad_interactions']['detected_ads']}, 关闭{self.visit_stats['ad_interactions']['close_button_clicks']}, 点击{self.visit_stats['ad_interactions']['ad_content_clicks']}") - else: - logger.error(f"❌ 第 {i+1} 次访问失败！") - - # 访问间隔 - if i < total_visits - 1: - delay = random.uniform(delay_range[0], delay_range[1]) - logger.info(f"⏳ 等待 {delay:.1f} 秒") - time.sleep(delay) - - # 最终统计 - self._print_final_universal_stats(success_count, total_visits) - - return success_count - - def _print_final_universal_stats(self, success_count, total_visits): - """打印最终统计信息""" - success_rate = (success_count / total_visits) * 100 - - logger.info(f"🎉 通用广告访问任务完成！") - logger.info(f"📊 访问统计:") - logger.info(f" 成功率: {success_count}/{total_visits} ({success_rate:.1f}%)") - logger.info(f" 检测广告总数: {self.visit_stats['ad_interactions']['detected_ads']}") - logger.info(f" 关闭按钮点击: {self.visit_stats['ad_interactions']['close_button_clicks']}") - logger.info(f" 广告内容点击: {self.visit_stats['ad_interactions']['ad_content_clicks']}") - logger.info(f" 忽略广告: {self.visit_stats['ad_interactions']['ignored_ads']}") - - total_interactions = (self.visit_stats['ad_interactions']['close_button_clicks'] + - self.visit_stats['ad_interactions']['ad_content_clicks'] + - self.visit_stats['ad_interactions']['ignored_ads']) - - if total_interactions > 0: - close_rate = (self.visit_stats['ad_interactions']['close_button_clicks'] / total_interactions) * 100 - click_rate = (self.visit_stats['ad_interactions']['ad_content_clicks'] / total_interactions) * 100 - ignore_rate = (self.visit_stats['ad_interactions']['ignored_ads'] / total_interactions) * 100 - - logger.info(f" 📈 用户行为分析:") - logger.info(f" 关闭率: {close_rate:.1f}%") - logger.info(f" 点击率: {click_rate:.1f}%") - logger.info(f" 忽略率: {ignore_rate:.1f}%") - - if self.visit_stats["ad_types_found"]: - logger.info(f" 🎯 发现的广告类型:") - for ad_type, count in self.visit_stats["ad_types_found"].items(): - logger.info(f" - {ad_type}: {count} 个") - - logger.info(f"💡 智能识别: 自动适应各种广告网络和类型") - -def main(): - """主函数""" - config_file = 'config.json' - - if not os.path.exists(config_file): - print(f"❌ 配置文件 {config_file} 不存在！") - return - - try: - bot = UniversalAdBot(config_file) - - print("=" * 80) - print("🎯 通用广告刷量机器人 (智能识别版)") - print("=" * 80) - print("💡 核心特性:") - print(" 🔍 智能广告识别 - 自动检测各种广告类型") - print(" 🎭 真实用户行为 - 75%概率讨厌广告") - print(" ❌ 智能关闭按钮 - 自动寻找并点击关闭按钮") - print(" 📱 移动端优先 - 85%概率使用移动设备") - print(" 🌐 通用适配 - 适用于任何广告网络") - print(" 📊 详细统计 - 检测率、关闭率、点击率") - print(" ⚠️ 请确保仅用于测试自己的网站！") - print() - print(f"🎯 目标网站: {bot.config['targets']['main_site']}") - print(f"🔍 支持广告网络: Google AdSense, MonetTag, PropellerAds 等") - print(f"😤 用户讨厌广告: 75%概率") - print() - - print("请选择运行模式:") - print("1. 💎 单次通用广告访问测试") - print("2. 🚀 连续通用广告访问 (使用配置参数)") - print("3. ⚙️ 自定义连续通用广告访问") - - choice = input("请输入选择 (1/2/3): ").strip() - - if choice == "1": - logger.info("🎬 开始单次通用广告访问测试") - success = bot.run_universal_ad_visit() - if success: - print("🎉 单次通用广告访问测试成功！") - else: - print("😞 单次通用广告访问测试失败！") - - elif choice == "2": - logger.info("🎬 开始连续通用广告访问") - success_count = bot.run_continuous_universal_visits() - total = bot.config['settings']['default_visits'] - print(f"🎉 连续通用广告访问完成！成功: {success_count}/{total}") - - elif choice == "3": - try: - visit_count = int(input("请输入访问次数: ").strip()) - min_delay = int(input("请输入最小延迟秒数: ").strip()) - max_delay = int(input("请输入最大延迟秒数: ").strip()) - - logger.info(f"🎬 开始自定义通用广告访问，次数: {visit_count}") - success_count = bot.run_continuous_universal_visits( - total_visits=visit_count, - delay_range=(min_delay, max_delay) - ) - - print(f"🎉 自定义通用广告访问完成！成功: {success_count}/{visit_count}") - - except ValueError: - print("❌ 输入参数错误！") - else: - print("❌ 无效选择！") - - except KeyboardInterrupt: - print("\n⚠️ 用户中断执行") - except Exception as e: - logger.error(f"程序执行出错: {e}") - print("❌ 程序执行出错，请查看日志文件 universal_ad_bot.log") - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/通用广告刷量机器人说明.md b/通用广告刷量机器人说明.md deleted file mode 100644 index e0fdf92..0000000 --- a/通用广告刷量机器人说明.md +++ /dev/null @@ -1,318 +0,0 @@ -# 🎯 通用广告刷量机器人 - 智能识别版 - -## 📋 功能概述 - -这是一个智能的广告刷量机器人，专为使用智能合一广告系统的网站设计。**无需修改您的HTML代码**，机器人能自动识别和处理各种广告类型，模拟真实用户行为。 - -### 🎯 核心特性 - -- **🔍 智能广告识别** - 自动检测各种广告网络和类型 -- **🎭 真实用户行为** - 75%概率讨厌广告并点击关闭按钮 -- **❌ 智能关闭按钮** - 自动寻找并点击关闭按钮 -- **📱 移动端优先** - 85%概率使用移动设备 -- **🌐 通用适配** - 适用于任何广告网络 -- **📊 详细统计** - 检测率、关闭率、点击率分析 - -⚠️ **重要提醒：仅用于测试自己的网站！** - -## 🔍 支持的广告网络 - -| 广告网络 | 检测支持 | 关闭支持 | 点击支持 | -|----------|----------|----------|----------| -| Google AdSense | ✅ | ✅ | ✅ | -| Google DoubleClick | ✅ | ✅ | ✅ | -| MonetTag | ✅ | ✅ | ✅ | -| PropellerAds | ✅ | ✅ | ✅ | -| Adsterra | ✅ | ✅ | ✅ | -| ExoClick | ✅ | ✅ | ✅ | -| PopAds | ✅ | ✅ | ✅ | -| Amazon Associates | ✅ | ✅ | ✅ | -| Outbrain | ✅ | ✅ | ✅ | -| Taboola | ✅ | ✅ | ✅ | -| RevContent | ✅ | ✅ | ✅ | -| MGID | ✅ | ✅ | ✅ | - -## 🎭 真实用户行为模拟 - -### 用户行为概率分布 -``` -📊 用户对广告的真实反应： - 😤 立即关闭广告: 45% - 🤔 思考后关闭: 30% - 📖 阅读后关闭: 15% - 🖱️ 点击广告内容: 10% -``` - -### 行为时间模拟 -| 行为类型 | 时间范围 | 说明 | -|----------|----------|------| -| 🔍 寻找关闭按钮 | 0.5-2.5秒 | 用户寻找X按钮的时间 | -| 🤔 思考时间 | 2-5秒 | 决定是否关闭广告 | -| 👀 反应时间 | 1-3秒 | 看到广告后的反应 | -| 🖱️ 点击操作 | 0.2-0.8秒 | 实际点击动作 | -| 😌 关闭后释放 | 0.5-1.5秒 | 关闭广告后的心理释放 | - -## 📁 文件结构 - -``` -通用广告刷量系统/ -├── universal_ad_bot.py # 通用广告机器人核心文件 -├── run_universal_ad_bot.bat # Windows一键启动脚本 -├── config.json # 配置文件（需要配置） -├── real_user_database.py # 真实用户数据库 -├── universal_ad_bot.log # 运行日志 -└── 通用广告刷量机器人说明.md # 本说明文档 -``` - -## 🚀 快速开始 - -### 1. 一键启动（推荐） -```bash -# 双击运行 -run_universal_ad_bot.bat -``` - -### 2. 手动启动 -```bash -# 安装依赖 -pip install requests - -# 运行机器人 -python universal_ad_bot.py -``` - -### 3. 配置文件设置 -编辑 `config.json` 文件： -```json -{ - "targets": { - "main_site": "https://your-website.com/" - }, - "settings": { - "default_visits": 10, - "min_delay": 60, - "max_delay": 300 - } -} -``` - -## 🔍 智能识别原理 - -### 广告脚本识别 -机器人通过以下方式识别广告： - -1. **脚本标签检测** - - 检测广告网络的JavaScript文件 - - 识别广告标签管理器 - - 分析广告追踪脚本 - -2. **HTML元素识别** - - 查找广告容器元素 - - 识别广告标记属性 - - 检测广告相关CSS类 - -3. **网络请求分析** - - 监控广告API请求 - - 分析广告加载模式 - - 跟踪广告交互事件 - -### 关闭按钮识别 -```javascript -// 机器人会自动寻找这些关闭按钮： -- button[class*='close'] -- span[class*='close'] -- [aria-label*='close'] -- span:contains('×') -- span:contains('✕') -- .close, .btn-close, .modal-close -``` - -## 📊 统计分析功能 - -### 实时统计 -- 🔍 **检测成功率** - 广告识别准确度 -- ❌ **关闭按钮点击次数** - 用户讨厌广告的体现 -- 🖱️ **广告内容点击次数** - 真实的广告互动 -- 🙈 **忽略广告次数** - 用户无视广告的情况 - -### 详细报告 -``` -📊 智能广告检测和交互统计: - 🔍 检测到广告: 25 个 - ❌ 关闭按钮点击: 19 次 (76%) - 🖱️ 广告内容点击: 4 次 (16%) - 🙈 忽略广告: 2 次 (8%) - - 🎯 发现的广告类型: - - Google AdSense: 8 个 - - MonetTag: 6 个 - - PropellerAds: 4 个 - - PopAds: 3 个 - - Adsterra: 2 个 - - ExoClick: 2 个 -``` - -## 🎮 游戏网站特化功能 - -### 游戏广告处理 -- **🎯 游戏前广告** - 70%概率跳过或关闭 -- **🎮 游戏中广告** - 80%概率立即关闭 -- **🏆 游戏结束广告** - 50%概率关闭，30%概率点击 - -### 游戏行为模拟 -```python -# 根据游戏类型调整行为模式 -puzzle_games = "思考型操作，停留时间长" -arcade_games = "快速操作，反应迅速" -action_games = "连续操作，专注度高" -``` - -## 📱 移动端优化 - -### 移动端特性 -- **📱 85%概率使用移动设备** - 符合现代用户习惯 -- **👆 触摸操作模拟** - 模拟手指点击行为 -- **📐 响应式适配** - 自动适应不同屏幕尺寸 -- **🔋 省电模式考虑** - 模拟移动设备的省电行为 - -### 移动端User-Agent -``` -iPhone Safari 17.1+ -Android Chrome 120.0+ -iPad Safari 17.1+ -Samsung Browser 22.0+ -``` - -## ⚙️ 高级配置 - -### 代理设置 -```json -{ - "proxy": { - "host": "proxy-server.com", - "port": "8080", - "username": "your-username", - "password": "your-password" - } -} -``` - -### 行为调整 -```json -{ - "ad_settings": { - "close_button_probability": 0.75, - "mobile_device_probability": 0.85, - "ad_annoyance_factor": 0.8 - } -} -``` - -### 时间模式 -```json -{ - "user_behavior_config": { - "find_close_button_time": [0.5, 2.5], - "think_time": [2, 5], - "reaction_time": [1, 3], - "click_delay": [0.2, 0.8] - } -} -``` - -## 🔧 故障排除 - -### 常见问题 - -1. **广告识别失败** - - 检查网站是否加载了广告脚本 - - 确认广告网络在支持列表中 - - 查看日志文件获取详细信息 - -2. **关闭按钮找不到** - - 广告可能使用非标准的关闭按钮 - - 检查广告是否为iframe形式 - - 尝试增加识别延迟时间 - -3. **网络连接问题** - - 检查代理配置是否正确 - - 确认目标网站可正常访问 - - 验证防火墙设置 - -### 日志分析 -```bash -# 查看实时日志 -tail -f universal_ad_bot.log - -# 查看错误信息 -grep "ERROR" universal_ad_bot.log - -# 查看广告检测结果 -grep "检测到" universal_ad_bot.log -``` - -## 📊 性能优化 - -### 内存优化 -- 🔄 **会话重用** - 减少连接开销 -- 🗑️ **自动清理** - 定期清理临时数据 -- 📦 **数据压缩** - 减少内存占用 - -### 速度优化 -- ⚡ **并行处理** - 同时处理多个广告 -- 🚀 **智能缓存** - 缓存常见广告模式 -- 📈 **预测加载** - 预测广告出现时机 - -## 🛡️ 安全注意事项 - -### 使用限制 -1. ⚠️ **仅用于测试自己的网站** -2. 🕐 **合理控制访问频率** -3. 🌐 **遵守网站服务条款** -4. 📊 **监控服务器负载** - -### 最佳实践 -1. 📈 **先进行小规模测试** -2. 📊 **分析广告效果数据** -3. 🎯 **优化广告位置和类型** -4. 📱 **重点关注移动端体验** - -## 🔮 未来功能计划 - -### 计划中的功能 -- 🤖 **AI广告识别** - 使用机器学习提高识别准确率 -- 🌍 **国际化支持** - 支持多语言广告网络 -- 📱 **APP广告支持** - 扩展到移动应用广告 -- 🎨 **视觉识别** - 基于图像识别广告元素 - -### 社区贡献 -- 📝 **提交广告网络** - 帮助识别新的广告网络 -- 🐛 **报告问题** - 反馈使用中的问题 -- 💡 **功能建议** - 提出新功能想法 - -## 📞 技术支持 - -如果遇到问题，请： -1. 📝 查看 `universal_ad_bot.log` 日志文件 -2. 🔍 检查配置文件是否正确 -3. 📱 确保网络连接正常 -4. 🎯 验证目标网站是否可访问 - -### 常用命令 -```bash -# 检查Python版本 -python --version - -# 安装依赖 -pip install requests - -# 运行机器人 -python universal_ad_bot.py - -# 查看日志 -type universal_ad_bot.log -``` - ---- - -💡 **核心优势：这个通用机器人能够自动适应任何使用智能合一广告系统的网站，无需修改HTML代码，智能识别并模拟真实用户对广告的反应。** \ No newline at end of file