Update app.py

app.py

@@ -1,175 +1,107 @@
 import dash
 from dash import dcc, html
-from dash.dependencies import Input, Output
 import pandas as pd
 import numpy as np
 from datetime import datetime, timedelta
 from sklearn.ensemble import IsolationForest
 from sklearn.preprocessing import StandardScaler
 import plotly.graph_objs as go
-from plotly.subplots import make_subplots
-import warnings
-warnings.filterwarnings('ignore')
 
-class CyberSecurityAnalytics:
-    def __init__(self):
-        self.generate_data()
-        self.detect_anomalies()
-        
-    def generate_data(self, n_samples=100):
-        current_time = datetime.now()
-        timestamps = [current_time - timedelta(minutes=i) for i in range(n_samples)]
-        
-        self.data = pd.DataFrame({
-            'timestamp': timestamps,
-            'network_traffic': np.random.normal(1000, 200, n_samples),
-            'failed_logins': np.random.poisson(5, n_samples),
-            'suspicious_ips': np.random.poisson(2, n_samples),
-            'data_exfiltration': np.random.normal(50, 10, n_samples),
-            'severity': np.random.choice(['Low', 'Medium', 'High'], n_samples),
-            'source_country': np.random.choice(['USA', 'China', 'Russia', 'UK', 'India'], n_samples),
-            'attack_type': np.random.choice(['DDoS', 'Brute Force', 'SQL Injection', 'XSS', 'Malware'], n_samples),
-            'port': np.random.choice([80, 443, 22, 3389, 8080], n_samples)
-        })
-        
-    def detect_anomalies(self):
-        isolation_forest = IsolationForest(contamination=0.1, random_state=42)
-        scaler = StandardScaler()
-        
-        features = ['network_traffic', 'failed_logins', 'suspicious_ips', 'data_exfiltration']
-        X = self.data[features]
-        X_scaled = scaler.fit_transform(X)
-        
-        self.data['is_anomaly'] = isolation_forest.fit_predict(X_scaled) == -1
+# Initialize the Dash app
+app = dash.Dash(__name__)
+server = app.server
 
-    def plot_network_traffic(self):
-        fig = go.Figure()
-        
-        fig.add_trace(go.Scatter(
-            x=self.data[~self.data['is_anomaly']]['timestamp'],
-            y=self.data[~self.data['is_anomaly']]['network_traffic'],
-            name='Normal Traffic',
-            mode='lines',
-            line=dict(color='blue')
-        ))
-        
-        fig.add_trace(go.Scatter(
-            x=self.data[self.data['is_anomaly']]['timestamp'],
-            y=self.data[self.data['is_anomaly']]['network_traffic'],
-            name='Anomalies',
-            mode='markers',
-            marker=dict(color='red', size=10)
-        ))
-        
-        fig.update_layout(
-            title='Network Traffic with Anomaly Detection',
-            xaxis_title='Time',
-            yaxis_title='Network Traffic (bytes)',
-            template='plotly_white'
-        )
-        return fig
+# Generate mock data
+def generate_mock_data(n_samples=100):
+    current_time = datetime.now()
+    timestamps = [current_time - timedelta(minutes=i) for i in range(n_samples)]
     
-    def plot_security_overview(self):
-        fig = make_subplots(
-            rows=3, cols=2,
-            subplot_titles=('Network Traffic', 'Failed Login Attempts',
-                          'Attack Types', 'Geographic Distribution',
-                          'Port Activity', 'Severity Distribution'),
-            specs=[[{'type': 'scatter'}, {'type': 'bar'}],
-                  [{'type': 'pie'}, {'type': 'pie'}],
-                  [{'type': 'bar'}, {'type': 'bar'}]]
-        )
-        
-        fig.add_trace(
-            go.Scatter(x=self.data['timestamp'], y=self.data['network_traffic'],
-                      name='Network Traffic'),
-            row=1, col=1
-        )
-        
-        fig.add_trace(
-            go.Bar(x=self.data['timestamp'], y=self.data['failed_logins'],
-                  name='Failed Logins'),
-            row=1, col=2
-        )
-        
-        attack_counts = self.data['attack_type'].value_counts()
-        fig.add_trace(
-            go.Pie(labels=attack_counts.index, values=attack_counts.values,
-                  name='Attack Types'),
-            row=2, col=1
-        )
-        
-        country_counts = self.data['source_country'].value_counts()
-        fig.add_trace(
-            go.Pie(labels=country_counts.index, values=country_counts.values,
-                  name='Countries'),
-            row=2, col=2
-        )
-        
-        port_counts = self.data['port'].value_counts()
-        fig.add_trace(
-            go.Bar(x=port_counts.index, y=port_counts.values,
-                  name='Port Activity'),
-            row=3, col=1
-        )
-        
-        severity_counts = self.data['severity'].value_counts()
-        fig.add_trace(
-            go.Bar(x=severity_counts.index, y=severity_counts.values,
-                  name='Severity',
-                  marker_color=['green', 'yellow', 'red']),
-            row=3, col=2
-        )
-        
-        fig.update_layout(height=1200, showlegend=False,
-                         title_text="Security Overview Dashboard")
-        return fig
+    data = pd.DataFrame({
+        'timestamp': timestamps,
+        'network_traffic': np.random.normal(1000, 200, n_samples),
+        'failed_logins': np.random.poisson(5, n_samples),
+        'suspicious_ips': np.random.poisson(2, n_samples),
+        'data_exfiltration': np.random.normal(50, 10, n_samples)
+    })
+    return data
 
-    def generate_metrics_table(self):
-        metrics = {
-            'Total Anomalies': int(self.data['is_anomaly'].sum()),
-            'High Severity Alerts': int(len(self.data[self.data['severity'] == 'High'])),
-            'Average Network Traffic': f"{float(self.data['network_traffic'].mean()):.2f}",
-            'Max Failed Logins': int(self.data['failed_logins'].max()),
-            'Unique Attack Sources': int(self.data['source_country'].nunique()),
-            'Most Common Attack': str(self.data['attack_type'].mode()[0]),
-            'Most Targeted Port': int(self.data['port'].mode()[0])
-        }
-        
-        return html.Table(
-            [html.Tr([html.Th(key), html.Td(value)]) for key, value in metrics.items()],
-            className='metrics-table'
-        )
+# Detect anomalies
+def detect_anomalies(df):
+    isolation_forest = IsolationForest(contamination=0.1, random_state=42)
+    scaler = StandardScaler()
+    
+    features = ['network_traffic', 'failed_logins', 'suspicious_ips', 'data_exfiltration']
+    X = df[features]
+    X_scaled = scaler.fit_transform(X)
+    
+    return isolation_forest.fit_predict(X_scaled) == -1
 
-# Initialize the Dash app
-app = dash.Dash(__name__)
-server = app.server
+# Generate data and detect anomalies
+df = generate_mock_data()
+anomalies = detect_anomalies(df)
 
-# Initialize analytics
-security_analytics = CyberSecurityAnalytics()
+# Create figures
+def create_network_traffic_figure():
+    fig = go.Figure()
+    
+    # Normal traffic
+    fig.add_trace(go.Scatter(
+        x=df[~anomalies]['timestamp'],
+        y=df[~anomalies]['network_traffic'],
+        name='Normal Traffic',
+        mode='lines',
+        line=dict(color='blue')
+    ))
+    
+    # Anomalies
+    fig.add_trace(go.Scatter(
+        x=df[anomalies]['timestamp'],
+        y=df[anomalies]['network_traffic'],
+        name='Anomalies',
+        mode='markers',
+        marker=dict(color='red', size=10)
+    ))
+    
+    fig.update_layout(
+        title='Network Traffic with Anomaly Detection',
+        xaxis_title='Time',
+        yaxis_title='Network Traffic (bytes)',
+        template='plotly_white'
+    )
+    return fig
+
+# Create metrics
+def generate_metrics():
+    return {
+        'Total Anomalies': int(sum(anomalies)),
+        'Average Network Traffic': f"{float(df['network_traffic'].mean()):.2f}",
+        'Max Failed Logins': int(df['failed_logins'].max()),
+    }
 
-# Define the layout
+# Define the app layout
 app.layout = html.Div([
     html.H1("AI-Enhanced Cybersecurity Dashboard", 
             style={'textAlign': 'center', 'padding': '20px'}),
     
+    # Metrics Section
     html.Div([
         html.H2("Key Metrics", style={'textAlign': 'center'}),
-        security_analytics.generate_metrics_table()
+        html.Div([
+            html.Table(
+                [html.Tr([html.Th(k), html.Td(v)]) for k, v in generate_metrics().items()],
+                style={'margin': 'auto', 'border-collapse': 'collapse'}
+            )
+        ])
     ], style={'padding': '20px'}),
     
+    # Network Traffic Graph
     html.Div([
         html.H2("Network Traffic Analysis", style={'textAlign': 'center'}),
-        dcc.Graph(figure=security_analytics.plot_network_traffic())
-    ], style={'padding': '20px'}),
-    
-    html.Div([
-        html.H2("Security Overview", style={'textAlign': 'center'}),
-        dcc.Graph(figure=security_analytics.plot_security_overview())
+        dcc.Graph(figure=create_network_traffic_figure())
     ], style={'padding': '20px'})
 ])
 
-# Add some CSS styling
+# Add CSS
 app.index_string = '''
 <!DOCTYPE html>
 <html>
@@ -184,17 +116,16 @@ app.index_string = '''
                 margin: 0;
                 background-color: #f0f2f5;
             }
-            .metrics-table {
+            table {
                 width: 100%;
-                border-collapse: collapse;
-                margin: 20px 0;
+                max-width: 600px;
             }
-            .metrics-table th, .metrics-table td {
+            th, td {
                 padding: 12px;
                 text-align: left;
                 border-bottom: 1px solid #ddd;
             }
-            .metrics-table th {
+            th {
                 background-color: #f8f9fa;
             }
         </style>