dc-securex 2.15.3__py3-none-any.whl

securex/client.py

@@ -0,0 +1,556 @@
+"""
+SecureX SDK - Main Client
+Backend-only anti-nuke protection system
+"""
+import discord
+import asyncio
+from pathlib import Path
+from typing import Dict, List, Callable, Optional
+from .backup.manager import BackupManager
+from .handlers.channel import ChannelHandler
+from .handlers.role import RoleHandler
+from .handlers.member import MemberHandler
+from .utils.whitelist import WhitelistManager
+from .utils.punishment import PunishmentExecutor
+from .models import ThreatEvent, BackupInfo
+
+
+class SecureX:
+    """
+    Main SecureX SDK class for anti-nuke protection.
+    Backend-only - no UI, no commands, just pure protection logic.
+    """
+    
+    def __init__(
+        self,
+        bot: discord.Client,
+        backup_dir: str = "./data/backups",
+        punishments: Optional[Dict[str, str]] = None,
+        timeout_duration: int = 600,
+        notify_user: bool = True
+    ):
+        """
+        Initialize SecureX SDK.
+        
+        Args:
+            bot: Your discord.Client or commands.Bot instance
+            backup_dir: Directory to store backups (default: ./data/backups)
+            punishments: Dict mapping violation types to punishment actions
+            timeout_duration: Duration in seconds for timeout punishment (default: 600)
+            notify_user: Whether to DM violators about punishment (default: True)
+        """
+        self.bot = bot
+        self.backup_dir = Path(backup_dir)
+        self.backup_dir.mkdir(parents=True, exist_ok=True)
+        
+        
+        self.backup_manager = BackupManager(self)
+        self.whitelist = WhitelistManager(self)
+        
+        
+        self._callbacks: Dict[str, List[Callable]] = {
+            'threat_detected': [],
+            'backup_completed': [],
+            'restore_completed': [],
+            'whitelist_changed': [],
+        }
+        
+        
+        self.punishments = {
+            
+            "bot_add": "none",
+            
+            
+            "channel_create": "none",
+            "channel_delete": "none",
+            "channel_update": "none",
+            
+            
+            "role_create": "none",
+            "role_delete": "none",
+            "role_update": "none",
+            
+            
+            "member_ban": "none",
+            "member_kick": "none",
+            "member_unban": "none",
+            "member_update": "none",
+            
+            
+            "webhook_create": "none",
+            "webhook_delete": "none",
+            "webhook_update": "none"
+        }
+        
+        
+        self.punisher = PunishmentExecutor(bot)
+        self.timeout_duration = timeout_duration
+        self.notify_punished_user = notify_user
+        
+        
+        self.action_queue = asyncio.Queue(maxsize=1000)
+        self.log_queue = asyncio.Queue(maxsize=1000)
+        self.cleanup_queue = asyncio.Queue(maxsize=1000)
+        
+        
+        self.whitelist_cache = {}  
+        self.punishment_cache = {}  
+        
+        
+        self._worker_tasks = []
+        
+        
+        self.channel_handler = ChannelHandler(self)
+        self.role_handler = RoleHandler(self)
+        self.member_handler = MemberHandler(self)
+        self.webhook_handler = WebhookHandler(self)
+        
+        
+        self._register_audit_log_listener()
+        
+        
+        self._register_events()
+    
+    def _register_audit_log_listener(self):
+        """Register INSTANT audit log event listener (v2.0 - 5-10ms response)"""
+        @self.bot.event
+        async def on_audit_log_entry_create(entry: discord.AuditLogEntry):
+            
+            try:
+                
+                await self.action_queue.put(entry)
+                await self.log_queue.put(entry)
+                await self.cleanup_queue.put(entry)
+            except asyncio.QueueFull as e:
+                print(f"⚠️ Queue full: {e}")
+
+    async def _action_worker(self):
+        """Worker 1: Process audit log entries and punish instantly"""
+        print("🔧 Action Worker started")
+        while True:
+            try:
+                
+                entry = await self.action_queue.get()
+                
+                guild = entry.guild
+                executor = entry.user
+                
+                
+                if executor.id == self.bot.user.id:
+                    continue
+                
+                
+                if executor.id == guild.owner_id:
+                    continue
+                
+                
+                whitelist_set = self.whitelist_cache.get(guild.id, set())
+                if executor.id in whitelist_set:
+                    continue
+                
+                
+                guild_punishments = self.punishment_cache.get(guild.id, self.punishments)
+                
+                
+                action_map = {
+                    
+                    discord.AuditLogAction.bot_add: "bot_add",
+
+                    
+                    discord.AuditLogAction.channel_create: "channel_create",
+                    discord.AuditLogAction.channel_delete: "channel_delete",
+                    discord.AuditLogAction.channel_update: "channel_update",
+
+                    
+                    discord.AuditLogAction.role_create: "role_create",
+                    discord.AuditLogAction.role_delete: "role_delete",
+                    discord.AuditLogAction.role_update: "role_update",
+
+                    
+                    discord.AuditLogAction.kick: "member_kick",
+                    discord.AuditLogAction.ban: "member_ban",
+                    discord.AuditLogAction.unban: "member_unban",
+                    discord.AuditLogAction.member_update: "member_update",
+                
+                    
+                    discord.AuditLogAction.webhook_create: "webhook_create",
+                    discord.AuditLogAction.webhook_delete: "webhook_delete",
+                    discord.AuditLogAction.webhook_update: "webhook_update",
+                }
+
+
+                
+                violation_type = action_map.get(entry.action)
+                if not violation_type:
+                    continue
+                
+                
+                punishment_action = guild_punishments.get(violation_type, "none")
+                
+                
+                punishment_result = "none"
+                
+                
+                if violation_type == "bot_add":
+                    try:
+                        bot_member = guild.get_member(entry.target.id)
+                        if bot_member:
+                            await bot_member.ban(reason="SecureX: Unauthorized bot addition")
+                            punishment_result = "banned_bot"
+                            print(f"🚀 INSTANT: Banned bot {entry.target.name} (added by {executor.name})")
+                    except Exception as e:
+                        print(f"Error banning bot: {e}")
+                
+                
+                if violation_type in ["member_kick", "member_ban", "member_unban","webhook_create"]:
+                    try:
+                        await guild.ban(executor, reason=f"SecureX: Unauthorized {violation_type}")
+                        punishment_result = "banned_violator"
+                        print(f"🔨 INSTANT: Banned {executor.name} for {violation_type}")
+                    except Exception as e:
+                        print(f"Error banning violator: {e}")
+                
+                if punishment_action != "none":
+                    try:
+                        punishment_result = await self.punisher.punish(
+                            guild=guild,
+                            user=executor,
+                            violation_type=violation_type,
+                            details=f"{violation_type} on {getattr(entry.target, 'name', 'Unknown')}",
+                            sdk=self
+                        )
+                        print(f"👢 {punishment_result.title()} {executor.name} for {violation_type}")
+                    except Exception as e:
+                        print(f"Cannot punish {executor.name}: {e}")
+                
+                
+                
+            except Exception as e:
+                print(f"Error in action worker: {e}")
+
+    async def _cleanup_worker(self):
+        """Worker 1.5: Process audit log entries and delete unauthorized creations instantly"""
+        print("🧹 Cleanup Worker started")
+        while True:
+            try:
+                
+                entry = await self.cleanup_queue.get()
+                
+                guild = entry.guild
+                executor = entry.user
+                
+                
+                if executor.id == self.bot.user.id:
+                    continue
+                
+                
+                if executor.id == guild.owner_id:
+                    continue
+                
+                
+                whitelist_set = self.whitelist_cache.get(guild.id, set())
+                if executor.id in whitelist_set:
+                    continue
+                
+                
+                if entry.action not in [
+                    discord.AuditLogAction.channel_create,
+                    discord.AuditLogAction.role_create,
+                    discord.AuditLogAction.webhook_create
+                ]:
+                    continue
+
+                
+                try:
+                    target = entry.target
+                    if not target:
+                        continue
+
+                    
+                    if entry.action == discord.AuditLogAction.role_create:
+                        role = guild.get_role(target.id)
+                        if role:
+                            await role.delete(reason="SecureX: Unauthorized role creation")
+                            print(f"🗑️ [Worker] Deleted unauthorized role: {role.name}")
+                    
+                    elif entry.action == discord.AuditLogAction.channel_create:
+                        channel = guild.get_channel(target.id)
+                        if channel:
+                            await channel.delete(reason="SecureX: Unauthorized channel creation")
+                            print(f"🗑️ [Worker] Deleted unauthorized channel: {channel.name}")
+                    
+                    elif entry.action == discord.AuditLogAction.webhook_create:
+                        
+                        webhooks = await guild.webhooks()
+                        for webhook in webhooks:
+                            if webhook.id == target.id:
+                                await webhook.delete(reason="SecureX: Unauthorized webhook creation")
+                                print(f"🗑️ [Worker] Deleted unauthorized webhook: {webhook.name}")
+                                break
+                            
+                
+                except (discord.Forbidden, discord.NotFound):
+                    pass
+                except Exception as e:
+                    print(f"Cleanup error: {e}")
+
+            except Exception as e:
+                print(f"Error in cleanup worker: {e}")
+    
+    async def _log_worker(self):
+        """Worker 2: Write logs to DB/webhooks - completely independent"""
+        print("📝 Log Worker started")
+        while True:
+            try:
+                
+                entry = await self.log_queue.get()
+                
+                guild = entry.guild
+                executor = entry.user
+                
+                
+                if executor.id == self.bot.user.id or executor.id == guild.owner_id:
+                    continue
+                
+                
+                action_map = {
+                    
+                    discord.AuditLogAction.bot_add: "bot_add",
+                    
+                    
+                    discord.AuditLogAction.channel_create: "channel_create",
+                    discord.AuditLogAction.channel_delete: "channel_delete",
+                    discord.AuditLogAction.channel_update: "channel_update",
+                    
+                    
+                    discord.AuditLogAction.role_create: "role_create",
+                    discord.AuditLogAction.role_delete: "role_delete",
+                    discord.AuditLogAction.role_update: "role_update",
+                    
+                    
+                    discord.AuditLogAction.kick: "member_kick",
+                    discord.AuditLogAction.ban: "member_ban",
+                    discord.AuditLogAction.unban: "member_unban",
+                    discord.AuditLogAction.member_update: "member_update",
+                    
+                    
+                    discord.AuditLogAction.webhook_create: "webhook_create",
+                    discord.AuditLogAction.webhook_delete: "webhook_delete",
+                    discord.AuditLogAction.webhook_update: "webhook_update",
+                }
+                
+                violation_type = action_map.get(entry.action)
+                if not violation_type:
+                    continue
+                
+                
+                threat = ThreatEvent(
+                    type=violation_type,
+                    guild_id=guild.id,
+                    actor_id=executor.id,
+                    target_id=entry.target.id if entry.target else None,
+                    target_name=getattr(entry.target, 'name', 'Unknown'),
+                    prevented=True,
+                    restored=False,
+                    punishment_action="logged"  
+                )
+                
+                
+                await self._trigger_callbacks('threat_detected', threat)
+                
+            except Exception as e:
+                print(f"Error in log worker: {e}")
+                
+    def _register_events(self):
+        """Register Discord event listeners for restorations"""
+
+        @self.bot.event
+        async def on_guild_channel_delete(channel):
+            await self.channel_handler.on_channel_delete(channel)
+        
+        @self.bot.event
+        async def on_guild_channel_update(before, after):
+            await self.channel_handler.on_channel_update(before, after)
+        
+
+        @self.bot.event
+        async def on_guild_role_delete(role):
+            await self.role_handler.on_role_delete(role)
+        
+        @self.bot.event
+        async def on_guild_role_update(before, after):
+            await self.role_handler.on_role_update(before, after)
+        
+        @self.bot.event
+        async def on_member_ban(guild, user):
+            await self.member_handler.on_member_ban(guild, user)
+        
+        @self.bot.event
+        async def on_member_update(before, after):
+            await self.member_handler.on_member_update(before, after)
+
+    
+    def on(self, event_name: str):
+        """
+        Decorator to register callbacks for SDK events.
+        
+        Usage:
+            @sx.on('threat_detected')
+            async def handle_threat(event: ThreatEvent):
+                print(f"Threat: {event.type}")
+        """
+        def decorator(func: Callable):
+            if event_name in self._callbacks:
+                self._callbacks[event_name].append(func)
+            return func
+        return decorator
+    
+    @property
+    def on_threat_detected(self):
+        """Convenience decorator for threat_detected events"""
+        return self.on('threat_detected')
+    
+    @property
+    def on_backup_completed(self):
+        """Convenience decorator for backup_completed events"""
+        return self.on('backup_completed')
+    
+    @property
+    def on_restore_completed(self):
+        """Convenience decorator for restore_completed events"""
+        return self.on('restore_completed')
+    
+    @property
+    def on_whitelist_changed(self):
+        """Convenience decorator for whitelist_changed events"""
+        return self.on('whitelist_changed')
+    
+    async def _trigger_callbacks(self, event_name: str, *args, **kwargs):
+        """Trigger all registered callbacks for an event"""
+        if event_name in self._callbacks:
+            for callback in self._callbacks[event_name]:
+                try:
+                    if asyncio.iscoroutinefunction(callback):
+                        await callback(*args, **kwargs)
+                    else:
+                        callback(*args, **kwargs)
+                except Exception as e:
+                    print(f"Error in callback for {event_name}: {e}")
+    
+    async def enable(
+        self,
+        guild_id: Optional[int] = None,
+        whitelist: Optional[List[int]] = None,
+        auto_backup: bool = True,
+        punishments: Optional[Dict[str, str]] = None,
+        timeout_duration: int = 600,
+        notify_user: bool = True
+    ):
+        """
+        Enable SecureX protection.
+        
+        Args:
+            guild_id: Guild ID to enable protection for (required if using whitelist)
+            whitelist: List of user IDs to whitelist (default: [])
+            auto_backup: Enable automatic backups every 30 minutes (default: True)
+            role_position_monitoring: Enable role position monitoring (default: True)
+            punishments: Dict mapping violation types to punishment actions
+                Example: {"channel_delete": "ban", "role_create": "kick"}
+                Available actions: "none", "warn", "timeout", "kick", "ban"
+            timeout_duration: Duration in seconds for timeout punishment (default: 600)
+            notify_user: Whether to DM violators about punishment (default: True)
+        """
+        
+        await self.whitelist.preload_all()
+        await self.backup_manager.preload_all()
+        
+        
+        if guild_id:
+            whitelist_data = await self.whitelist.get_all(guild_id)
+            self.whitelist_cache[guild_id] = set(whitelist_data)
+            print(f"📋 Loaded {len(whitelist_data)} whitelisted users into cache")
+        
+        if whitelist and guild_id:
+            for user_id in whitelist:
+                await self.whitelist.add(guild_id, user_id)
+            
+            self.whitelist_cache[guild_id] = self.whitelist_cache.get(guild_id, set()) | set(whitelist)
+        
+        
+        if punishments:
+            self.punishments.update(punishments)
+        
+        if guild_id:
+            self.punishment_cache[guild_id] = self.punishments.copy()
+            print(f"⚡ Punishment cache populated for guild {guild_id}")
+        
+        
+        self._worker_tasks.append(asyncio.create_task(self._action_worker()))
+        self._worker_tasks.append(asyncio.create_task(self._log_worker()))
+        self._worker_tasks.append(asyncio.create_task(self._cleanup_worker()))
+        print("🚀 Started 3 independent workers (Action, Log, Cleanup)")
+        print("⚡ Broadcast architecture - zero dependencies between workers")
+        
+        if auto_backup:
+            
+            self.backup_manager.start_auto_backup()
+            
+            self.backup_manager.start_auto_refresh()
+        
+        self.timeout_duration = timeout_duration
+        self.notify_punished_user = notify_user
+        
+        
+        if punishments:
+            enabled_punishments = {k: v for k, v in self.punishments.items() if v != "none"}
+            if enabled_punishments:
+                print(f"⚠️  Punishments configured for {len(enabled_punishments)} violation types")
+        
+        print("✅ SecureX SDK v2.0 - Ultra-fast audit log system ACTIVE")
+        print("⚡ Response time: 5-10ms (100x faster than v1.x)")
+        
+        
+        if guild_id:
+            backup = await self.backup_manager.create_backup(guild_id)
+            if backup.success:
+                print(f"✅ Backup completed for guild {guild_id}: "
+                      f"{backup.channel_count} channels, {backup.role_count} roles")
+    
+    
+    async def create_backup(self, guild_id: int) -> BackupInfo:
+        """
+        Create a backup for the specified guild.
+        
+        Args:
+            guild_id: The guild ID to backup
+            
+        Returns:
+            BackupInfo object with backup results
+        """
+        return await self.backup_manager.create_backup(guild_id)
+    
+    async def restore_channel(self, guild: discord.Guild, channel: discord.abc.GuildChannel):
+        """
+        Restore a deleted channel from backup.
+        
+        Args:
+            guild: The guild object
+            channel: The deleted channel object
+            
+        Returns:
+            The newly created channel or None if restoration failed
+        """
+        return await self.backup_manager.restore_channel(guild, channel)
+    
+    async def restore_role(self, guild: discord.Guild, role_id: int) -> bool:
+        """
+        Restore a deleted role from backup.
+        
+        Args:
+            guild: The guild object
+            role_id: The ID of the deleted role
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        return await self.backup_manager.restore_role(guild, role_id)

securex/handlers/__init__.py

@@ -0,0 +1,8 @@
+"""Handlers package - contains protection logic"""
+
+from .channel import ChannelHandler
+from .role import RoleHandler
+from .member import MemberHandler
+from .webhook import WebhookHandler
+
+__all__ = ['ChannelHandler', 'RoleHandler', 'MemberHandler', 'WebhookHandler']

securex/handlers/channel.py

@@ -0,0 +1,97 @@
+"""
+Channel protection handler for SecureX SDK.
+"""
+import discord
+import asyncio
+from datetime import datetime, timedelta
+
+
+class ChannelHandler:
+    """Handles channel protection logic"""
+    
+    def __init__(self, sdk):
+        self.sdk = sdk
+        self.bot = sdk.bot
+        self.backup_manager = sdk.backup_manager
+        self.whitelist = sdk.whitelist
+    
+    async def _is_authorized(self, guild: discord.Guild, user_id: int) -> bool:
+        """Check if user is authorized (owner or whitelisted)"""
+        if guild.owner_id == user_id:
+            return True
+        if user_id == self.bot.user.id:
+            return True
+        return await self.whitelist.is_whitelisted(guild.id, user_id)
+    
+ 
+    async def on_channel_delete(self, channel: discord.abc.GuildChannel):
+        """Restore unauthorized channel deletions"""
+        try:
+            guild = channel.guild
+            print(f"🔍 [Debug] Channel deleted: {channel.name} ({channel.id})")
+            await asyncio.sleep(1)
+            
+            
+            from datetime import timezone
+            cutoff_time = datetime.now(timezone.utc) - timedelta(seconds=30)
+            
+            found_entry = False
+            async for entry in guild.audit_logs(limit=50, action=discord.AuditLogAction.channel_delete):
+                if entry.created_at < cutoff_time:
+                    break
+                    
+                if entry.target.id == channel.id:
+                    found_entry = True
+                    authorized = await self._is_authorized(guild, entry.user.id)
+                    print(f"👤 [Debug] Executor: {entry.user.name} ({entry.user.id}) | Authorized: {authorized}")
+                    
+                    if not authorized:
+                        print(f"🛠️ [Debug] Unauthorized deletion detected. Triggering restoration...")
+                        
+                        new_channel = await self.backup_manager.restore_channel(guild, channel)
+                        if new_channel:
+                            print(f"🔄 Restored unauthorized channel deletion: {channel.name}")
+                        
+                        
+                        if new_channel and isinstance(channel, discord.CategoryChannel):
+                            await self.backup_manager.restore_category_children(
+                                guild, 
+                                channel.id,
+                                new_channel  
+                            )
+                    else:
+                        print(f"✅ [Debug] Deletion by authorized user. Skipping restoration.")
+                    break
+            
+            if not found_entry:
+                print(f"⚠️ [Debug] Could not find audit log entry for channel deletion of {channel.name}")
+                        
+        except Exception as e:
+            print(f"❌ [Debug] Error in on_channel_delete: {e}")
+    
+    async def on_channel_update(self, before: discord.abc.GuildChannel, after: discord.abc.GuildChannel):
+        """Restore unauthorized channel permission changes"""
+        try:
+            
+            if (before.overwrites == after.overwrites and 
+                before.position == after.position):
+                return
+            
+            guild = after.guild
+            await asyncio.sleep(0.5)
+            
+            
+            from datetime import timezone
+            cutoff_time = datetime.now(timezone.utc) - timedelta(seconds=30)
+            
+            async for entry in guild.audit_logs(limit=50, oldest_first=False):
+                if entry.created_at < cutoff_time:
+                    break
+                    
+                if entry.action == discord.AuditLogAction.channel_update:
+                    if entry.target and entry.target.id == after.id:
+                        if not await self._is_authorized(guild, entry.user.id):
+                            await self.backup_manager.restore_channel_permissions(guild, after.id)
+                        break
+        except Exception:
+            pass