ai_root_shield 0.4.0 → 1.0.0

data/lib/ai_root_shield/dashboard/web_dashboard.rb

@@ -0,0 +1,441 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'json'
+require 'erb'
+
+module AiRootShield
+  module Dashboard
+    # Optional GUI dashboard for log analysis and visualization
+    class WebDashboard < Sinatra::Base
+      set :port, 4567
+      set :bind, '0.0.0.0'
+      set :public_folder, File.join(__dir__, 'public')
+      set :views, File.join(__dir__, 'views')
+      
+      # Dashboard routes
+      get '/' do
+        @title = 'AI Root Shield Dashboard'
+        erb :index
+      end
+      
+      get '/api/status' do
+        content_type :json
+        {
+          status: 'running',
+          version: AiRootShield::VERSION,
+          timestamp: Time.now.utc.iso8601
+        }.to_json
+      end
+      
+      post '/api/analyze' do
+        content_type :json
+        
+        begin
+          # Parse uploaded device logs
+          device_logs = JSON.parse(request.body.read)
+          
+          # Perform security analysis
+          results = perform_security_analysis(device_logs)
+          
+          # Generate visualization data
+          visualization_data = generate_visualization_data(results)
+          
+          {
+            success: true,
+            results: results,
+            visualization: visualization_data
+          }.to_json
+          
+        rescue JSON::ParserError => e
+          status 400
+          { success: false, error: "Invalid JSON: #{e.message}" }.to_json
+        rescue StandardError => e
+          status 500
+          { success: false, error: "Analysis failed: #{e.message}" }.to_json
+        end
+      end
+      
+      get '/api/reports' do
+        content_type :json
+        
+        # Get list of available reports
+        reports = get_available_reports
+        { reports: reports }.to_json
+      end
+      
+      get '/api/reports/:id' do
+        content_type :json
+        
+        report_id = params[:id]
+        report = get_report_by_id(report_id)
+        
+        if report
+          report.to_json
+        else
+          status 404
+          { success: false, error: 'Report not found' }.to_json
+        end
+      end
+      
+      get '/dashboard' do
+        @title = 'Security Dashboard'
+        @recent_scans = get_recent_scans
+        erb :dashboard
+      end
+      
+      get '/visualization' do
+        @title = 'Risk Visualization'
+        erb :visualization
+      end
+      
+      get '/reports' do
+        @title = 'Security Reports'
+        @reports = get_available_reports
+        erb :reports
+      end
+      
+      get '/settings' do
+        @title = 'Dashboard Settings'
+        erb :settings
+      end
+      
+      private
+      
+      def perform_security_analysis(device_logs)
+        platform = device_logs['platform']&.downcase
+        
+        case platform
+        when 'android'
+          android_module = AiRootShield::Platform::AndroidSecurityModule.new
+          android_module.analyze_device_security(device_logs)
+        when 'ios'
+          ios_module = AiRootShield::Platform::IosSecurityModule.new
+          ios_module.analyze_device_security(device_logs)
+        else
+          # Generic analysis
+          {
+            risk_score: 0,
+            risk_factors: [],
+            platform: 'unknown',
+            analysis_type: 'generic'
+          }
+        end
+      end
+      
+      def generate_visualization_data(results)
+        {
+          risk_score_chart: generate_risk_score_chart(results),
+          risk_factors_chart: generate_risk_factors_chart(results),
+          timeline_data: generate_timeline_data(results),
+          heatmap_data: generate_heatmap_data(results),
+          compliance_radar: generate_compliance_radar(results)
+        }
+      end
+      
+      def generate_risk_score_chart(results)
+        risk_score = results[:risk_score] || 0
+        
+        {
+          type: 'gauge',
+          data: {
+            value: risk_score,
+            max: 100,
+            ranges: [
+              { from: 0, to: 20, color: '#28a745', label: 'LOW' },
+              { from: 21, to: 40, color: '#ffc107', label: 'MEDIUM' },
+              { from: 41, to: 70, color: '#fd7e14', label: 'HIGH' },
+              { from: 71, to: 100, color: '#dc3545', label: 'CRITICAL' }
+            ]
+          },
+          options: {
+            title: 'Overall Risk Score',
+            subtitle: determine_risk_level(risk_score)
+          }
+        }
+      end
+      
+      def generate_risk_factors_chart(results)
+        risk_factors = results[:risk_factors] || []
+        
+        # Categorize risk factors
+        categories = {
+          'Root/Jailbreak' => risk_factors.select { |f| f.match?(/ROOT|JAILBREAK/) }.size,
+          'Emulator' => risk_factors.select { |f| f.match?(/EMULATOR/) }.size,
+          'Hooking' => risk_factors.select { |f| f.match?(/FRIDA|XPOSED|SUBSTRATE/) }.size,
+          'Integrity' => risk_factors.select { |f| f.match?(/INTEGRITY|SIGNING/) }.size,
+          'Network' => risk_factors.select { |f| f.match?(/NETWORK|TLS|PROXY/) }.size,
+          'Hardware' => risk_factors.select { |f| f.match?(/HARDWARE|TEE|BIOMETRIC/) }.size
+        }
+        
+        {
+          type: 'bar',
+          data: {
+            labels: categories.keys,
+            datasets: [{
+              label: 'Risk Factors Count',
+              data: categories.values,
+              backgroundColor: [
+                '#dc3545', '#fd7e14', '#ffc107',
+                '#28a745', '#17a2b8', '#6f42c1'
+              ]
+            }]
+          },
+          options: {
+            title: 'Risk Factors by Category',
+            responsive: true
+          }
+        }
+      end
+      
+      def generate_timeline_data(results)
+        # Generate timeline data for risk evolution
+        {
+          type: 'line',
+          data: {
+            labels: generate_time_labels,
+            datasets: [{
+              label: 'Risk Score Over Time',
+              data: generate_risk_timeline(results),
+              borderColor: '#dc3545',
+              backgroundColor: 'rgba(220, 53, 69, 0.1)',
+              tension: 0.4
+            }]
+          },
+          options: {
+            title: 'Risk Score Timeline',
+            scales: {
+              y: {
+                beginAtZero: true,
+                max: 100
+              }
+            }
+          }
+        }
+      end
+      
+      def generate_heatmap_data(results)
+        # Generate security heatmap data
+        security_areas = [
+          'Authentication', 'Authorization', 'Data Protection',
+          'Network Security', 'Code Integrity', 'Runtime Protection',
+          'Hardware Security', 'Compliance'
+        ]
+        
+        heatmap_values = security_areas.map do |area|
+          calculate_area_risk_score(area, results)
+        end
+        
+        {
+          type: 'heatmap',
+          data: {
+            labels: security_areas,
+            values: heatmap_values
+          },
+          options: {
+            title: 'Security Areas Heatmap',
+            colorScale: {
+              low: '#28a745',
+              medium: '#ffc107',
+              high: '#dc3545'
+            }
+          }
+        }
+      end
+      
+      def generate_compliance_radar(results)
+        compliance_frameworks = [
+          'OWASP MASVS', 'NIST Cybersecurity', 'ISO 27001',
+          'PCI DSS', 'GDPR', 'SOX', 'HIPAA'
+        ]
+        
+        compliance_scores = compliance_frameworks.map do |framework|
+          calculate_compliance_score(framework, results)
+        end
+        
+        {
+          type: 'radar',
+          data: {
+            labels: compliance_frameworks,
+            datasets: [{
+              label: 'Compliance Score',
+              data: compliance_scores,
+              backgroundColor: 'rgba(40, 167, 69, 0.2)',
+              borderColor: '#28a745',
+              pointBackgroundColor: '#28a745'
+            }]
+          },
+          options: {
+            title: 'Compliance Framework Assessment',
+            scale: {
+              ticks: {
+                beginAtZero: true,
+                max: 100
+              }
+            }
+          }
+        }
+      end
+      
+      def get_available_reports
+        # Mock data for available reports
+        [
+          {
+            id: 'report_001',
+            title: 'Android Security Analysis',
+            platform: 'android',
+            timestamp: Time.now - 3600,
+            risk_score: 45,
+            status: 'completed'
+          },
+          {
+            id: 'report_002',
+            title: 'iOS Security Analysis',
+            platform: 'ios',
+            timestamp: Time.now - 7200,
+            risk_score: 23,
+            status: 'completed'
+          },
+          {
+            id: 'report_003',
+            title: 'Cross-Platform Analysis',
+            platform: 'unified',
+            timestamp: Time.now - 10800,
+            risk_score: 67,
+            status: 'completed'
+          }
+        ]
+      end
+      
+      def get_report_by_id(report_id)
+        # Mock report retrieval
+        reports = get_available_reports
+        reports.find { |r| r[:id] == report_id }
+      end
+      
+      def get_recent_scans
+        # Mock recent scans data
+        [
+          {
+            id: 'scan_001',
+            platform: 'android',
+            timestamp: Time.now - 1800,
+            risk_score: 34,
+            device_model: 'Pixel 6'
+          },
+          {
+            id: 'scan_002',
+            platform: 'ios',
+            timestamp: Time.now - 3600,
+            risk_score: 12,
+            device_model: 'iPhone 13'
+          },
+          {
+            id: 'scan_003',
+            platform: 'android',
+            timestamp: Time.now - 5400,
+            risk_score: 78,
+            device_model: 'Samsung Galaxy S21'
+          }
+        ]
+      end
+      
+      def determine_risk_level(score)
+        case score
+        when 0..20
+          'LOW RISK'
+        when 21..40
+          'MEDIUM RISK'
+        when 41..70
+          'HIGH RISK'
+        when 71..100
+          'CRITICAL RISK'
+        else
+          'UNKNOWN'
+        end
+      end
+      
+      def generate_time_labels
+        # Generate time labels for the last 24 hours
+        (0..23).map { |h| "#{h}:00" }
+      end
+      
+      def generate_risk_timeline(results)
+        # Generate mock timeline data
+        base_score = results[:risk_score] || 0
+        (0..23).map { |_| base_score + rand(-10..10) }
+      end
+      
+      def calculate_area_risk_score(area, results)
+        # Calculate risk score for specific security area
+        risk_factors = results[:risk_factors] || []
+        
+        case area
+        when 'Authentication'
+          risk_factors.count { |f| f.match?(/AUTH|BIOMETRIC/) } * 10
+        when 'Authorization'
+          risk_factors.count { |f| f.match?(/PERMISSION|ACCESS/) } * 10
+        when 'Data Protection'
+          risk_factors.count { |f| f.match?(/ENCRYPTION|DATA/) } * 10
+        when 'Network Security'
+          risk_factors.count { |f| f.match?(/NETWORK|TLS|PROXY/) } * 10
+        when 'Code Integrity'
+          risk_factors.count { |f| f.match?(/INTEGRITY|SIGNING/) } * 10
+        when 'Runtime Protection'
+          risk_factors.count { |f| f.match?(/RUNTIME|RASP/) } * 10
+        when 'Hardware Security'
+          risk_factors.count { |f| f.match?(/HARDWARE|TEE/) } * 10
+        when 'Compliance'
+          risk_factors.count { |f| f.match?(/COMPLIANCE|POLICY/) } * 10
+        else
+          0
+        end
+      end
+      
+      def calculate_compliance_score(framework, results)
+        # Calculate compliance score for specific framework
+        risk_score = results[:risk_score] || 0
+        
+        # Compliance score is inverse of risk score with framework-specific adjustments
+        base_compliance = 100 - risk_score
+        
+        case framework
+        when 'OWASP MASVS'
+          [base_compliance + 10, 100].min
+        when 'NIST Cybersecurity'
+          [base_compliance + 5, 100].min
+        when 'ISO 27001'
+          base_compliance
+        when 'PCI DSS'
+          [base_compliance - 5, 0].max
+        when 'GDPR'
+          [base_compliance + 15, 100].min
+        when 'SOX'
+          [base_compliance - 10, 0].max
+        when 'HIPAA'
+          base_compliance
+        else
+          base_compliance
+        end
+      end
+      
+      # Start dashboard server
+      def self.start_dashboard(options = {})
+        port = options[:port] || 4567
+        bind = options[:bind] || '0.0.0.0'
+        
+        puts "Starting AI Root Shield Dashboard on http://#{bind}:#{port}"
+        puts "Dashboard features:"
+        puts "  • Real-time security analysis"
+        puts "  • Risk score visualization"
+        puts "  • Compliance reporting"
+        puts "  • Historical trend analysis"
+        
+        set :port, port
+        set :bind, bind
+        
+        run!
+      end
+    end
+  end
+end