Tiktok - 检存安全防护机制

TKCheck框架之安全防护机制：保护用户数据与系统安全

大家好！在前面的系列文章中，我们深入探讨了TKCheck框架的核心组件——TikTok账号验证系统、EasysuCloudHelper云服务授权模块、多线程请求调度系统和数据解析与处理模块。今天，我们将聚焦于TKCheck框架的安全防护机制。

在处理大量用户账号信息的验证工具中，安全性是一个至关重要的考量因素。TKCheck框架通过多层次的安全设计，确保用户数据的保密性、完整性和可用性，同时防止系统被滥用或攻击。

一、数据加密存储

TKCheck对所有敏感数据采用强加密存储，确保即使数据被未授权访问，也无法轻易解读：

class DataEncryptor:
    """数据加密器"""
    def __init__(self, key=None):
        """初始化加密器"""
        # 如果没有提供密钥，使用设备信息生成
        if key is None:
            key = self._generate_device_key()
            
        # 确保密钥长度符合AES-256要求
        self.key = hashlib.sha256(key.encode()).digest()
        
    def _generate_device_key(self):
        """根据设备信息生成密钥"""
        # 收集设备唯一信息
        device_info = [
            str(uuid.getnode()),  # MAC地址
            platform.node(),      # 主机名
            platform.processor(), # CPU信息
            os.getenv('USERNAME', 'unknown')  # 用户名
        ]
        
        # 组合并哈希
        device_str = ":".join(device_info)
        return hashlib.sha256(device_str.encode()).hexdigest()
        
    def encrypt(self, data):
        """加密数据"""
        if isinstance(data, str):
            data = data.encode('utf-8')
        elif isinstance(data, dict) or isinstance(data, list):
            data = json.dumps(data).encode('utf-8')
            
        # 生成随机IV
        iv = os.urandom(16)
        
        # 创建加密器
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        
        # 添加填充
        padder = padding.PKCS7(AES.block_size).padder()
        padded_data = padder.update(data) + padder.finalize()
        
        # 加密
        encrypted_data = cipher.encrypt(padded_data)
        
        # 组合IV和密文
        result = iv + encrypted_data
        
        # 返回Base64编码结果
        return base64.b64encode(result).decode('utf-8')
        
    def decrypt(self, encrypted_data):
        """解密数据"""
        try:
            # 解码Base64
            data = base64.b64decode(encrypted_data)
            
            # 提取IV和密文
            iv = data[:16]
            ciphertext = data[16:]
            
            # 创建解密器
            cipher = AES.new(self.key, AES.MODE_CBC, iv)
            
            # 解密
            padded_data = cipher.decrypt(ciphertext)
            
            # 移除填充
            unpadder = padding.PKCS7(AES.block_size).unpadder()
            data = unpadder.update(padded_data) + unpadder.finalize()
            
            # 返回解密结果
            return data.decode('utf-8')
        except Exception as e:
            logger.error(f"解密失败: {str(e)}")
            return None

这个数据加密器提供了以下安全特性：

1. 使用AES-256-CBC高强度加密算法
2. 基于设备信息生成的唯一密钥，增加了跨设备使用的难度
3. 随机初始化向量(IV)，防止相同数据产生相同密文
4. 标准的PKCS7填充，确保任意长度数据都能正确加密
5. 全面的异常处理，防止解密失败导致程序崩溃

在实际应用中，所有敏感数据都通过这个加密器处理：

# 创建全局加密器
encryptor = DataEncryptor()

# 加密保存账号文件路径
def save_recent_file_path(file_path):
    encrypted_path = encryptor.encrypt(file_path)
    with open("./数据/.recent_file", "w") as f:
        f.write(encrypted_path)
        
# 加密保存结果
def save_encrypted_result(result, file_path):
    encrypted_result = encryptor.encrypt(result)
    with open(file_path, "w") as f:
        f.write(encrypted_result)

这种加密存储确保了即使攻击者获取了TKCheck的数据文件，也无法轻易获取其中的敏感信息。

二、网络通信安全

在与TikTok API通信时，TKCheck采取了多项措施确保网络通信的安全性：

class SecureApiClient:
    """安全API客户端"""
    def __init__(self):
        # 创建会话对象
        self.session = requests.Session()
        
        # 配置重试机制
        retries = Retry(
            total=3,
            backoff_factor=0.5,
            status_forcelist=[500, 502, 503, 504],
            allowed_methods=["GET", "POST"]
        )
        
        # 配置连接适配器
        self.session.mount('https://', HTTPAdapter(max_retries=retries))
        
        # 设置默认超时
        self.timeout = 10
        
        # 配置UA轮转器
        self.user_agents = [
            "com.ss.android.tt.creator/320906 (Linux; U; Android 9; en_US; SM-G960N; Build/PQ3A.190605.07291528;tt-ok/3.12.13.4-tiktok)",
            "com.ss.android.tt.creator/320906 (Linux; U; Android 10; en_US; Pixel 4; Build/QD1A.190821.007;tt-ok/3.12.13.4-tiktok)",
            "com.ss.android.tt.creator/320906 (Linux; U; Android 11; en_US; OnePlus 8T; Build/RKQ1.201217.002;tt-ok/3.12.13.4-tiktok)"
        ]
        
    def _get_random_ua(self):
        """获取随机UA"""
        return random.choice(self.user_agents)
        
    def post(self, url, data=None, json=None, params=None, headers=None):
        """发送安全POST请求"""
        try:
            # 准备请求头
            if headers is None:
                headers = {}
                
            # 设置UA
            if 'User-Agent' not in headers:
                headers['User-Agent'] = self._get_random_ua()
                
            # 添加安全头部
            headers.update({
                'Accept-Encoding': 'gzip',
                'Connection': 'Keep-Alive',
                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                'passport-sdk-version': '6010090',
                'x-vc-bdturing-sdk-version': '2.3.4.i18n'
            })
            
            # 发送请求
            logger.debug(f"发送POST请求: {url}")
            response = self.session.post(
                url,
                data=data,
                json=json,
                params=params,
                headers=headers,
                timeout=self.timeout,
                verify=True  # 在生产环境中确保SSL验证
            )
            
            # 检查响应
            response.raise_for_status()
            
            return response
            
        except requests.exceptions.HTTPError as e:
            logger.error(f"HTTP错误: {str(e)}")
            raise
        except requests.exceptions.ConnectionError as e:
            logger.error(f"连接错误: {str(e)}")
            raise
        except requests.exceptions.Timeout as e:
            logger.error(f"请求超时: {str(e)}")
            raise
        except requests.exceptions.RequestException as e:
            logger.error(f"请求异常: {str(e)}")
            raise
        finally:
            # 记录请求日志
            self._log_request(url, headers)
            
    def _log_request(self, url, headers):
        """记录请求日志（移除敏感信息）"""
        # 创建头部副本并移除敏感信息
        safe_headers = headers.copy()
        for sensitive_key in ['Authorization', 'Cookie']:
            if sensitive_key in safe_headers:
                safe_headers[sensitive_key] = '[REDACTED]'
                
        # 记录安全的请求信息
        logger.debug(f"API请求: {url}, 头部: {safe_headers}")

这个安全API客户端实现了以下网络安全特性：

1. 启用HTTPS通信，防止中间人攻击
2. 启用SSL证书验证，防止假冒服务器
3. 随机UA轮转，降低特征识别风险
4. 重试机制，提高请求可靠性
5. 超时控制，防止资源耗尽
6. 安全日志记录，避免敏感信息泄露

通过这些措施，TKCheck确保了与API服务器的通信安全，减少了网络层面的风险。

三、防爬策略规避

为了避免触发TikTok的反爬虫机制，TKCheck实现了多种策略规避措施：

class AntiCrawlDefense:
    """反爬虫防御"""
    def __init__(self):
        # 请求计数器
        self.request_count = 0
        
        # 上次请求时间
        self.last_request_time = 0
        
        # 请求历史
        self.request_history = deque(maxlen=100)
        
        # 锁
        self.lock = threading.Lock()
        
        # 退避时间范围（秒）
        self.min_delay = 0.5
        self.max_delay = 2.0
        
        # IP冷却时间（小时）
        self.ip_cooldown = 6
        
    def pre_request(self):
        """请求前调用，决定是否应该等待"""
        with self.lock:
            current_time = time.time()
            
            # 计算上次请求距离现在的时间
            time_diff = current_time - self.last_request_time
            
            # 检查是否需要随机延迟
            if time_diff < self.min_delay:
                # 计算需要等待的时间
                delay = random.uniform(self.min_delay, self.max_delay)
                logger.debug(f"应用反爬虫延迟: {delay:.2f}秒")
                time.sleep(delay)
                
            # 更新请求计数和时间
            self.request_count += 1
            self.last_request_time = time.time()
            self.request_history.append(self.last_request_time)
            
            # 检查是否达到IP冷却阈值
            if self.should_cooldown():
                cooldown_time = self.calculate_cooldown_time()
                logger.warning(f"检测到频繁请求，建议IP冷却: {cooldown_time:.1f}小时")
                return False
                
            return True
            
    def should_cooldown(self):
        """判断是否需要冷却IP"""
        # 如果请求历史不足，不需要冷却
        if len(self.request_history) < 50:
            return False
            
        # 计算最近50个请求的时间跨度
        oldest = min(list(self.request_history)[-50:])
        newest = max(list(self.request_history)[-50:])
        timespan = newest - oldest
        
        # 如果50个请求在短时间内完成，建议冷却
        return timespan < 300  # 5分钟内50个请求
        
    def calculate_cooldown_time(self):
        """计算建议的冷却时间"""
        # 根据请求数量动态调整冷却时间
        if self.request_count > 1000:
            return self.ip_cooldown * 2
        elif self.request_count > 500:
            return self.ip_cooldown * 1.5
        else:
            return self.ip_cooldown

这个反爬虫防御模块实现了以下策略：

1. 请求间随机延迟，模拟人类行为
2. 请求速率监控，避免过于频繁的请求
3. IP冷却建议，定期轮换IP或暂停请求
4. 动态调整策略，根据请求历史调整防御措施

在实际使用中，这个模块与API请求紧密集成：

# 创建全局防爬策略
anti_crawl = AntiCrawlDefense()

def getdomain(email):
    """向TikTok API发送请求"""
    try:
        # 应用反爬策略
        if not anti_crawl.pre_request():
            return {
                'message': 'error: IP需要冷却'
            }
            
        # ... 执行正常请求 ...
    except Exception as e:
        return {
            'message': f'error: {str(e)}'
        }

通过这些策略规避措施，TKCheck能够有效地避免触发TikTok的反爬虫机制，保持长期稳定的使用。

四、权限与授权控制

TKCheck实现了严格的权限和授权控制，确保只有授权用户才能使用系统功能：

class AuthorizationManager:
    """授权管理器"""
    def __init__(self):
        # 授权API地址
        self.auth_api = "https://api.easysu.cloud/auth"
        
        # 授权缓存
        self.auth_cache = {}
        
        # 授权级别定义
        self.permission_levels = {
            "basic": 1,    # 基础功能
            "standard": 2, # 标准功能
            "premium": 3,  # 高级功能
            "admin": 10    # 管理员
        }
        
    def verify_auth_code(self, auth_code):
        """验证授权码"""
        try:
            # 检查缓存
            if auth_code in self.auth_cache:
                cached_result = self.auth_cache[auth_code]
                # 检查缓存是否过期
                if cached_result['expire_time'] > time.time():
                    return cached_result
                    
            # 构建验证请求
            data = {
                "auth_code": auth_code,
                "device_id": self._get_device_id(),
                "app_id": "tk_check_v1",
                "timestamp": int(time.time())
            }
            
            # 添加签名
            data["sign"] = self._generate_signature(data)
            
            # 发送验证请求
            response = requests.post(
                f"{self.auth_api}/verify",
                json=data,
                timeout=10
            )
            
            result = response.json()
            
            if result["code"] == 0:
                # 授权有效
                auth_result = {
                    "valid": True,
                    "level": result["data"]["level"],
                    "expire_time": result["data"]["expire_time"],
                    "features": result["data"]["features"],
                    "message": "授权有效"
                }
                
                # 缓存结果
                self.auth_cache[auth_code] = auth_result
                
                return auth_result
            else:
                # 授权无效
                return {
                    "valid": False,
                    "message": result["message"]
                }
                
        except Exception as e:
            logger.error(f"授权验证失败: {str(e)}")
            return {
                "valid": False,
                "message": f"验证异常: {str(e)}"
            }
            
    def check_permission(self, auth_result, required_level):
        """检查是否有指定级别的权限"""
        if not auth_result.get("valid", False):
            return False
            
        # 获取用户级别
        user_level = auth_result.get("level", "")
        
        # 转换为数值
        user_level_value = self.permission_levels.get(user_level, 0)
        required_level_value = self.permission_levels.get(required_level, 99)
        
        # 比较权限级别
        return user_level_value >= required_level_value
        
    def check_feature_access(self, auth_result, feature_name):
        """检查是否可以使用特定功能"""
        if not auth_result.get("valid", False):
            return False
            
        # 获取用户可用功能列表
        features = auth_result.get("features", [])
        
        # 检查功能是否在列表中
        return feature_name in features
        
    def _get_device_id(self):
        """获取设备ID"""
        mac = uuid.getnode()
        cpu_info = platform.processor()
        system_info = platform.system() + platform.version()
        
        device_str = f"{mac}|{cpu_info}|{system_info}"
        return hashlib.md5(device_str.encode()).hexdigest()
        
    def _generate_signature(self, data):
        """生成签名"""
        # 按键排序并拼接
        sign_str = "&".join([f"{k}={v}" for k, v in sorted(data.items())])
        
        # 添加密钥
        sign_str += "&key=easysu_secret_key_2023"
        
        # 计算MD5
        return hashlib.md5(sign_str.encode()).hexdigest()

这个授权管理器实现了以下安全机制：

1. 基于云服务的授权验证，防止离线破解
2. 设备绑定，限制一个授权码在多台设备上使用
3. 分级权限控制，根据用户等级限制功能访问
4. 功能级权限控制，细粒度管理功能使用权限
5. 本地缓存加速，减少重复验证请求
6. 安全签名机制，防止请求伪造

在界面层面，根据用户权限动态调整可用功能：

def update_ui_based_on_permissions(self):
    """根据权限更新UI"""
    # 获取当前授权结果
    auth_result = self.auth_manager.verify_auth_code(self.auth_code)
    
    # 基础功能：所有授权用户
    if auth_result.get("valid", False):
        self.ui.pushButtonStartCheckReg.setEnabled(True)
        
        # 批量功能：需要标准及以上权限
        has_batch = self.auth_manager.check_permission(auth_result, "standard")
        self.ui.pushButtonBatchCheck.setEnabled(has_batch)
        
        # 导出功能：需要特定功能权限
        has_export = self.auth_manager.check_feature_access(auth_result, "export_results")
        self.ui.pushButtonExport.setEnabled(has_export)
        
        # 高级设置：需要高级权限
        has_advanced = self.auth_manager.check_permission(auth_result, "premium")
        self.ui.menuAdvanced.setEnabled(has_advanced)
        
        # 管理功能：仅管理员可用
        is_admin = self.auth_manager.check_permission(auth_result, "admin")
        self.ui.menuAdmin.setVisible(is_admin)
    else:
        # 未授权用户禁用所有功能
        self.ui.pushButtonStartCheckReg.setEnabled(False)
        self.ui.pushButtonBatchCheck.setEnabled(False)
        self.ui.pushButtonExport.setEnabled(False)
        self.ui.menuAdvanced.setEnabled(False)
        self.ui.menuAdmin.setVisible(False)

通过这种严格的权限和授权控制，TKCheck确保了软件的商业价值，同时防止了功能被滥用。

五、日志安全处理

TKCheck实现了安全的日志处理机制，确保日志既有助于问题排查，又不会泄露敏感信息：

class SecureLogger:
    """安全日志记录器"""
    def __init__(self, log_dir="./数据/日志"):
        # 创建日志目录
        os.makedirs(log_dir, exist_ok=True)
        
        # 配置日志格式
        self.formatter = logging.Formatter(
            '%(asctime)s [%(levelname)s] %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S'
        )
        
        # 创建文件处理器
        log_file = os.path.join(log_dir, f"tkcheck_{time.strftime('%Y%m%d')}.log")
        self.file_handler = logging.FileHandler(log_file, encoding='utf-8')
        self.file_handler.setFormatter(self.formatter)
        
        # 创建控制台处理器
        self.console_handler = logging.StreamHandler()
        self.console_handler.setFormatter(self.formatter)
        
        # 配置root logger
        self.logger = logging.getLogger()
        self.logger.setLevel(logging.INFO)
        self.logger.addHandler(self.file_handler)
        self.logger.addHandler(self.console_handler)
        
        # 敏感信息模式列表
        self.sensitive_patterns = [
            re.compile(r'(\w{1,3})(\w+)@(\w+\.\w+)'),  # 邮箱
            re.compile(r'(\+\d{1,3})(\d+)(\d{4})'),   # 电话
            re.compile(r'(auth_code=)([a-zA-Z0-9]+)'), # 授权码
            re.compile(r'(api_key=)([a-zA-Z0-9]+)')    # API密钥
        ]
        
    def info(self, message):
        """记录信息日志"""
        sanitized = self._sanitize_sensitive_info(message)
        self.logger.info(sanitized)
        
    def error(self, message):
        """记录错误日志"""
        sanitized = self._sanitize_sensitive_info(message)
        self.logger.error(sanitized)
        
    def warning(self, message):
        """记录警告日志"""
        sanitized = self._sanitize_sensitive_info(message)
        self.logger.warning(sanitized)
        
    def debug(self, message):
        """记录调试日志"""
        sanitized = self._sanitize_sensitive_info(message)
        self.logger.debug(sanitized)
        
    def _sanitize_sensitive_info(self, message):
        """清理消息中的敏感信息"""
        if not isinstance(message, str):
            return message
            
        sanitized = message
        
        # 处理邮箱
        sanitized = self.sensitive_patterns[0].sub(r'\1***@\3', sanitized)
        
        # 处理电话
        sanitized = self.sensitive_patterns[1].sub(r'\1***\3', sanitized)
        
        # 处理授权码
        sanitized = self.sensitive_patterns[2].sub(r'\1***', sanitized)
        
        # 处理API密钥
        sanitized = self.sensitive_patterns[3].sub(r'\1***', sanitized)
        
        return sanitized

这个安全日志记录器提供了以下安全特性：

1. 自动清理敏感信息，如邮箱、电话号码、授权码和API密钥
2. 将日志文件按日期分割，便于管理
3. 标准化的日志格式，包含时间和日志级别
4. 同时输出到文件和控制台，方便调试

在实际使用中，所有日志记录都通过这个安全记录器处理：

# 创建全局安全日志记录器
logger = SecureLogger()

# 记录敏感信息
logger.info(f"检查账号: user@example.com") 
# 记录为: "检查账号: use***@example.com"

logger.error(f"无法连接到账号: +1234567890") 
# 记录为: "无法连接到账号: +123***7890"

通过这种日志安全处理，TKCheck确保了系统运行记录的完整性，同时保护了用户敏感信息。

六、安全自检与防护

为了防止程序被篡改或逆向工程，TKCheck实现了安全自检和防护机制：

class SecuritySelfCheck:
    """安全自检"""
    def __init__(self):
        # 预计算的文件哈希值
        self.expected_hashes = {
            "TKCheck.exe": "a1b2c3d4e5f6...",  # 示例哈希值
            "core/api_client.py": "f6e5d4c3b2a1...",
            "core/data_processor.py": "1a2b3c4d5e6f..."
        }
        
        # 安全相关环境检查项
        self.security_checks = [
            self._check_debugger,
            self._check_virtualization,
            self._check_file_integrity,
            self._check_dns_poisoning
        ]
        
    def run_security_checks(self):
        """运行所有安全检查"""
        results = {}
        
        for check_func in self.security_checks:
            check_name = check_func.__name__.replace("_check_", "")
            try:
                result = check_func()
                results[check_name] = result
                
                # 如果检查失败，记录警告
                if not result["passed"]:
                    logger.warning(f"安全检查 '{check_name}' 失败: {result['message']}")
            except Exception as e:
                logger.error(f"安全检查 '{check_name}' 错误: {str(e)}")
                results[check_name] = {
                    "passed": False,
                    "message": f"检查过程出错: {str(e)}"
                }
                
        return results
        
    def _check_file_integrity(self):
        """检查文件完整性"""
        for filename, expected_hash in self.expected_hashes.items():
            try:
                if os.path.exists(filename):
                    # 计算文件哈希
                    file_hash = self._calculate_file_hash(filename)
                    
                    # 比较哈希值
                    if file_hash != expected_hash:
                        return {
                            "passed": False,
                            "message": f"文件 '{filename}' 哈希值不匹配"
                        }
            except Exception as e:
                return {
                    "passed": False,
                    "message": f"无法验证文件 '{filename}': {str(e)}"
                }
                
        return {
            "passed": True,
            "message": "所有文件完整性检查通过"
        }
        
    def _check_debugger(self):
        """检查是否在调试器中运行"""
        try:
            # Windows平台检查
            if platform.system() == "Windows":
                kernel32 = ctypes.windll.kernel32
                if kernel32.IsDebuggerPresent():
                    return {
                        "passed": False,
                        "message": "检测到调试器"
                    }
            
            # Linux/Mac平台检查（简化版）
            if platform.system() in ["Linux", "Darwin"]:
                # 检查父进程是否为调试器
                parent_process = psutil.Process(os.getppid())
                if "gdb" in parent_process.name() or "lldb" in parent_process.name():
                    return {
                        "passed": False,
                        "message": "检测到调试器"
                    }
                    
            return {
                "passed": True,
                "message": "未检测到调试器"
            }
        except Exception as e:
            # 如果检查过程出错，返回通过
            # 这样可以避免因检查机制失败而阻止正常用户使用
            return {
                "passed": True,
                "message": f"调试器检查过程出错: {str(e)}"
            }
            
    def _calculate_file_hash(self, filename):
        """计算文件SHA256哈希值"""
        sha256_hash = hashlib.sha256()
        
        with open(filename, "rb") as f:
            # 读取并更新哈希字符串值
            for byte_block in iter(lambda: f.read(4096), b""):
                sha256_hash.update(byte_block)
                
        return sha256_hash.hexdigest()

这个安全自检模块实现了以下防护措施：

1. 文件完整性验证，检测程序文件是否被篡改
2. 调试器检测，防止程序在调试环境中运行
3. 虚拟化环境检测，识别可能的分析环境
4. DNS欺骗检测，保护网络通信安全

在应用启动时，执行安全自检：

def application_startup(self):
    """应用程序启动"""
    # 创建安全自检实例
    security_check = SecuritySelfCheck()
    
    # 运行安全检查
    check_results = security_check.run_security_checks()
    
    # 如果有关键安全项未通过，可以选择退出
    critical_failures = [k for k, v in check_results.items() 
                        if not v["passed"] and k in ["file_integrity", "dns_poisoning"]]
                        
    if critical_failures:
        logger.critical(f"安全检查失败: {critical_failures}")
        
        # 在实际应用中，可以根据需要决定是否退出
        # 这里仅显示警告，允许继续运行
        QMessageBox.warning(
            self,
            "安全警告",
            "程序检测到安全风险，部分功能可能受限。\n" +
            "如果此问题持续出现，请联系支持团队。"
        )

通过这些安全自检和防护机制，TKCheck能够抵御多种潜在的安全威胁，保护程序的安全运行。

总结

TKCheck框架的安全防护机制通过多层次的安全策略，全面保护了用户数据安全和系统完整性：

1. 数据加密存储，确保敏感信息不被未授权访问
2. 网络通信安全，防止数据传输过程中被窃取或篡改
3. 防爬策略规避，确保系统稳定长期运行
4. 权限与授权控制，防止功能被滥用
5. 日志安全处理，保护用户隐私的同时支持问题排查
6. 安全自检与防护，抵御程序分析和篡改

这些安全机制不仅保护了用户数据和系统安全，也帮助TKCheck在保持高效功能的同时，遵守了数据保护和隐私相关的最佳实践。

至此，我们完成了TKCheck框架的五篇系列文章，从TikTok账号验证系统到EasysuCloudHelper云服务授权模块，再到多线程请求调度系统、数据解析与处理模块，最后是安全防护机制。这一系列文章全面展示了TKCheck框架的设计理念和技术实现，希望能对您的开发工作有所启发！