Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

3.7 KB
Raw Blame
"""
Security Alert Model for ServerKit.

Stores security alerts from anomaly detection.
"""

from datetime import datetime
from app import db
from app.models.mixins import uuid_pk


class SecurityAlert(db.Model):
    """Security alerts from anomaly detection"""
    __tablename__ = 'security_alerts'

    id = uuid_pk()
    server_id = db.Column(db.String(36), db.ForeignKey('servers.id'), nullable=True, index=True)

    # Alert classification
    alert_type = db.Column(db.String(50), nullable=False, index=True)
    # Types: auth_failure, rate_limit, new_ip, suspicious_pattern, ip_blocked, replay_attack

    severity = db.Column(db.String(20), nullable=False, default='info', index=True)
    # Severities: info, warning, critical

    # Source information
    source_ip = db.Column(db.String(45))  # IPv4 or IPv6

    # Alert details (JSON for flexibility)
    details = db.Column(db.JSON)
    # Example: {"attempts": 5, "window": "1m", "threshold": 5}

    # Alert status
    status = db.Column(db.String(20), default='open', index=True)
    # Statuses: open, acknowledged, resolved

    # Timestamps
    created_at = db.Column(db.DateTime, default=datetime.utcnow, index=True)
    acknowledged_at = db.Column(db.DateTime)
    acknowledged_by = db.Column(db.Integer, db.ForeignKey('users.id'), index=True)
    resolved_at = db.Column(db.DateTime)
    resolved_by = db.Column(db.Integer, db.ForeignKey('users.id'), index=True)

    # Relationships
    server = db.relationship('Server', backref=db.backref('security_alerts', lazy='dynamic'))

    def to_dict(self):
        return {
            'id': self.id,
            'server_id': self.server_id,
            'server_name': self.server.name if self.server else None,
            'alert_type': self.alert_type,
            'severity': self.severity,
            'source_ip': self.source_ip,
            'details': self.details,
            'status': self.status,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'acknowledged_at': self.acknowledged_at.isoformat() if self.acknowledged_at else None,
            'acknowledged_by': self.acknowledged_by,
            'resolved_at': self.resolved_at.isoformat() if self.resolved_at else None,
            'resolved_by': self.resolved_by,
        }

    @staticmethod
    def create_alert(
        alert_type: str,
        severity: str = 'info',
        server_id: str = None,
        source_ip: str = None,
        details: dict = None
    ) -> 'SecurityAlert':
        """
        Create a new security alert.

        Args:
            alert_type: Type of alert (auth_failure, rate_limit, etc.)
            severity: Alert severity (info, warning, critical)
            server_id: Associated server ID (optional)
            source_ip: Source IP address (optional)
            details: Additional details as dict (optional)

        Returns:
            SecurityAlert: The created alert
        """
        alert = SecurityAlert(
            alert_type=alert_type,
            severity=severity,
            server_id=server_id,
            source_ip=source_ip,
            details=details or {}
        )
        db.session.add(alert)
        db.session.commit()
        return alert

    def acknowledge(self, user_id: int = None):
        """Mark alert as acknowledged."""
        self.status = 'acknowledged'
        self.acknowledged_at = datetime.utcnow()
        self.acknowledged_by = user_id
        db.session.commit()

    def resolve(self, user_id: int = None):
        """Mark alert as resolved."""
        self.status = 'resolved'
        self.resolved_at = datetime.utcnow()
        self.resolved_by = user_id
        db.session.commit()

    def __repr__(self):
        return f'<SecurityAlert {self.alert_type} ({self.severity}) - {self.status}>'