Remove incorrectly uploaded files and corrected them

Scanner/Vunerability_Scanner/createTargets.py

@@ -0,0 +1,161 @@
+import csv
+import os
+from gvm.connections import TLSConnection
+from gvm.protocols.gmp import Gmp
+from gvm.transforms import EtreeTransform
+
+# Set up data directory
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.abspath(os.path.join(BASE_DIR, "..", "data"))
+os.makedirs(DATA_DIR, exist_ok=True)
+
+
+# OpenVAS Configuration
+OPENVAS_HOST = "localhost"
+OPENVAS_PORT = 9390
+USERNAME = "admin"
+PASSWORD = "admin"
+
+
+ACTIVE_HOSTS_CSV = os.path.join(DATA_DIR, "active_hosts.csv")
+TARGET_ID_CSV = os.path.join(DATA_DIR, "target_id.csv")
+
+
+def get_port_list_id(gmp):
+    """
+    Retrieve a valid port list ID.
+    """
+    port_lists = gmp.get_port_lists()
+    default_port_list_id = None
+    for port_list in port_lists.findall("port_list"):
+        name = port_list.find("name").text
+        port_list_id = port_list.get("id")
+        print(f"Port List: {name} (ID: {port_list_id})")
+        if "OpenVAS Default" in name:
+            default_port_list_id = port_list_id
+
+    # If "OpenVAS Default" is not found, use the first available port list
+    if not default_port_list_id and len(port_lists.findall("port_list")) > 0:
+
+        default_port_list_id = port_lists.find("port_list").get("id")
+        print(f"'OpenVAS Default' not found. Using the first available port list with ID: {default_port_list_id}")
+
+    return default_port_list_id
+
+
+def target_exists(gmp, ip):
+    """
+    Check if a target already exists for the given IP and return its target_id if it does.
+    """
+    targets = gmp.get_targets()
+    for target in targets.findall("target"):
+        if target.find("hosts").text == ip:
+            target_id = target.get("id")
+            print(f"Target for IP {ip} already exists with ID: {target_id}")
+            return target_id
+    return None
+
+
+def create_target(gmp, name, ip, port_list_id):
+    """
+    Create a target in OpenVAS.
+    """
+    response = gmp.create_target(name=name, hosts=[ip], port_list_id=port_list_id)
+    target_id = response.get("id")
+    if target_id:
+        print(f"Created target '{name}' for IP '{ip}' with ID: {target_id}")
+    else:
+        print(f"Failed to create target for IP {ip}. Check logs.")
+    return target_id
+
+
+def save_target_id_to_csv(ip, target_id):
+    """
+    Save the target ID to the target_id.csv file if it's not already there.
+    """
+    existing_data = []
+    try:
+        # Read existing data from the CSV
+        with open(TARGET_ID_CSV, "r", newline="") as csvfile:
+            reader = csv.reader(csvfile)
+            existing_data = list(reader)
+    except FileNotFoundError:
+        # If the file doesn't exist, it will be created later
+        pass
+
+    # Check if the IP is already in the CSV
+    for row in existing_data:
+        if row[0] == ip:
+            print(f"IP {ip} already recorded in {TARGET_ID_CSV}")
+            return
+
+    # Append the new target ID to the CSV
+    with open(TARGET_ID_CSV, "a", newline="") as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerow([ip, target_id])
+    print(f"Saved target ID {target_id} for IP {ip} to {TARGET_ID_CSV}")
+
+
+def read_csv_to_ip_list(csv_file):
+    """
+    Read the CSV file and extract IPs into a list.
+    """
+    ip_list = []
+    with open(csv_file, newline="") as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            ip_list.append(row["IP"])
+    return ip_list
+
+
+def main():
+    connection = TLSConnection(hostname=OPENVAS_HOST, port=OPENVAS_PORT)
+    with Gmp(connection=connection, transform=EtreeTransform()) as gmp:
+        # Authenticate with OpenVAS
+        gmp.authenticate(username=USERNAME, password=PASSWORD)
+        print("Authenticated with OpenVAS")
+
+        # Get a valid port list ID
+        port_list_id = get_port_list_id(gmp)
+        if not port_list_id:
+            print("Failed to retrieve a valid port list. Exiting.")
+            return
+
+        # Read IPs from the active hosts CSV
+        ip_list = read_csv_to_ip_list(ACTIVE_HOSTS_CSV)
+        if not ip_list:
+            print("No IPs found in the CSV file. Exiting.")
+            return
+
+        print(f"Found {len(ip_list)} active hosts.")
+
+        # Process each IP
+        for ip in ip_list:
+            print(f"Processing IP: {ip}")
+
+            # Check if target already exists
+            target_id = target_exists(gmp, ip)
+            if target_id:
+                # Save the existing target ID to the CSV if not already recorded
+                save_target_id_to_csv(ip, target_id)
+                continue
+
+            # Create target if it doesn't exist
+            target_name = f"Target for {ip}"
+            target_id = create_target(gmp, target_name, ip, port_list_id)
+            if target_id:
+                save_target_id_to_csv(ip, target_id)
+            else:
+                print(f"Failed to create target for IP {ip}. Continuing.")
+
+
+if __name__ == "__main__":
+    # Ensure the target_id.csv file exists with headers
+    try:
+        with open(TARGET_ID_CSV, "x", newline="") as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerow(["IP", "Target ID"])  # Write headers if the file doesn't exist
+    except FileExistsError:
+        pass  # File already exists, no need to create
+
+    main()

Scanner/Vunerability_Scanner/generate_reports copy.py

@@ -0,0 +1,73 @@
+# generate_reports.py (fixed)
+import csv
+import subprocess
+import os
+from datetime import datetime
+
+REPORT_IDS_CSV = "data/report_ids.csv"
+CONSOLIDATED_CSV = "data/openvasscan.csv"
+TEMP_DIR = "temp_reports"
+
+def append_to_consolidated(temp_csv):
+    if not os.path.exists(temp_csv):
+        print(f"Warning: File {temp_csv} not found, skipping")
+        return
+
+    file_exists = os.path.isfile(CONSOLIDATED_CSV)
+    
+    with open(temp_csv, 'r') as infile, open(CONSOLIDATED_CSV, 'a', newline='') as outfile:
+        reader = csv.reader(infile)
+        writer = csv.writer(outfile)
+        
+        if file_exists:
+            next(reader, None)
+            
+        for row in reader:
+            writer.writerow(row)
+
+def main():
+    os.makedirs(TEMP_DIR, exist_ok=True)
+    
+    with open(REPORT_IDS_CSV, 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            report_id = row['report_id']
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            base_name = f"report_{report_id}_{timestamp}"
+            temp_csv = os.path.join(TEMP_DIR, base_name)
+            
+            cmd = [
+                'gvm-script',
+                '--gmp-username', 'admin',
+                '--gmp-password', 'admin',  # Fix typo here ("assword" → "password")
+                'tls', '--hostname', '127.0.0.1', '--port', '9390',
+                'export-csv-report.gmp.py',
+                report_id,
+                temp_csv
+            ]
+            
+            try:
+                result = subprocess.run(
+                    cmd,
+                    check=True,
+                    capture_output=True,
+                    text=True
+                )  # Added closing parenthesis
+                print(f"Command output: {result.stdout}")
+                
+                final_path = f"{temp_csv}.csv"
+                
+                if os.path.exists(final_path):
+                    append_to_consolidated(final_path)
+                    os.remove(final_path)
+                    print(f"Processed {final_path}")
+                else:
+                    print(f"Error: Expected output file {final_path} not found")
+
+            except subprocess.CalledProcessError as e:
+                print(f"Error generating report {report_id}: {e.stderr}")
+
+    print(f"Consolidation complete. Final file: {CONSOLIDATED_CSV}")
+
+if __name__ == "__main__":
+    main()  # Properly closed main function

Scanner/Vunerability_Scanner/generate_reports.py

@@ -0,0 +1,75 @@
+import os
+import csv
+import base64
+from gvm.connections import TLSConnection
+from gvm.protocols.gmp import Gmp
+from gvm.transforms import EtreeTransform
+
+# Set up data directory
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.abspath(os.path.join(BASE_DIR, "..", "data"))
+os.makedirs(DATA_DIR, exist_ok=True)
+
+REPORT_ID_CSV = os.path.join(DATA_DIR, "report_id.csv")
+OPENVAS_SCAN_CSV = os.path.join(DATA_DIR, "openvasscan.csv")
+
+OPENVAS_HOST = "localhost"
+OPENVAS_PORT = 9390
+USERNAME = "admin"
+PASSWORD = "admin"
+
+CSV_FORMAT_ID = "c1645568-627a-11e3-a660-406186ea4fc5"
+
+def get_report_csv_data(gmp, report_id):
+    report = gmp.get_report(report_id=report_id, report_format_id=CSV_FORMAT_ID)
+    base64_data = report.find(".//report_format").tail
+    if base64_data:
+        try:
+            decoded_data = base64.b64decode(base64_data).decode("utf-8")
+            return decoded_data
+        except Exception as e:
+            print(f"[✗] Error decoding report {report_id}: {e}")
+            return None
+    else:
+        print(f"[!] No data found in report {report_id}")
+        return None
+
+def save_individual_report(report_id, content):
+    report_path = os.path.join(DATA_DIR, f"report_{report_id}.csv")
+    with open(report_path, "w", encoding="utf-8") as f:
+        f.write(content)
+    print(f"[✓] Saved individual report to {report_path}")
+
+def append_to_aggregate(content, is_first=False):
+    mode = "w" if is_first else "a"
+    with open(OPENVAS_SCAN_CSV, mode, encoding="utf-8") as f:
+        if not is_first:
+            # Skip header row to not duplicate rows
+            content = "\n".join(content.splitlines()[1:])
+        f.write(content + "\n")
+
+def main():
+    connection = TLSConnection(hostname=OPENVAS_HOST, port=OPENVAS_PORT)
+    with Gmp(connection=connection, transform=EtreeTransform()) as gmp:
+        gmp.authenticate(username=USERNAME, password=PASSWORD)
+        print("Authenticated with OpenVAS")
+
+        first = True
+        try:
+            with open(REPORT_ID_CSV, newline="") as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    report_id = row["Report ID"]
+                    print(f"Fetching report: {report_id}")
+                    content = get_report_csv_data(gmp, report_id)
+                    if content:
+                        #save_individual_report(report_id, content)
+                        append_to_aggregate(content, is_first=first)
+                        first = False
+        except FileNotFoundError:
+            print(f"[✗] Missing file: {REPORT_ID_CSV}")
+        except KeyError:
+            print(f"[✗] 'Report ID' column not found in {REPORT_ID_CSV}")
+
+if __name__ == "__main__":
+    main()

Scanner/Vunerability_Scanner/getreports.py

@@ -0,0 +1,73 @@
+
+import csv
+import time
+import os
+from gvm.connections import TLSConnection
+from gvm.protocols.gmp import Gmp
+from gvm.transforms import EtreeTransform
+
+# Set up data directory
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.abspath(os.path.join(BASE_DIR, "..", "data"))
+os.makedirs(DATA_DIR, exist_ok=True)
+
+TASK_ID_CSV = os.path.join(DATA_DIR, "task_id.csv")
+REPORT_ID_CSV = os.path.join(DATA_DIR, "report_id.csv")
+
+OPENVAS_HOST = "localhost"
+OPENVAS_PORT = 9390
+USERNAME = "admin"
+PASSWORD = "admin"
+
+def wait_for_task_and_get_report(gmp, task_id):
+    while True:
+        response = gmp.get_task(task_id=task_id)
+        task = response.find("task")
+
+        if task is None:
+            print(f"Task with ID {task_id} not found. Skipping.")
+            return None
+
+        status = task.find("status").text
+        progress = task.find("progress").text
+        print(f"Task {task_id} - Status: {status}, Progress: {progress}%")
+
+
+        if status == "Done":
+            report_elem = task.find("last_report/report")
+            if report_elem is not None:
+                report_id = report_elem.get("id")
+                print(f"[✓] Task {task_id} finished. Report ID: {report_id}")
+                return report_id
+            else:
+                print(f"[✗] Task {task_id} is done, but no report found.")
+                return None
+        time.sleep(10)
+
+def main():
+    connection = TLSConnection(hostname=OPENVAS_HOST, port=OPENVAS_PORT)
+    with Gmp(connection=connection, transform=EtreeTransform()) as gmp:
+        gmp.authenticate(username=USERNAME, password=PASSWORD)
+        print("Authenticated with OpenVAS")
+
+        try:
+            with open(TASK_ID_CSV, newline="") as csvfile:
+                reader = csv.DictReader(csvfile)
+                task_ids = [row["Task ID"] for row in reader]
+
+            with open(REPORT_ID_CSV, "w", newline="") as outfile:
+                writer = csv.writer(outfile)
+                writer.writerow(["Task ID", "Report ID"])  # Header
+
+                for task_id in task_ids:
+                    print(f"Waiting for report from Task ID: {task_id}")
+                    report_id = wait_for_task_and_get_report(gmp, task_id)
+                    if report_id:
+                        writer.writerow([task_id, report_id])
+        except FileNotFoundError:
+            print(f"File not found: {TASK_ID_CSV}. Please run taskmaker.py first.")
+        except KeyError:
+            print("Error: CSV must contain a 'Task ID' column.")
+
+if __name__ == "__main__":
+    main()

Scanner/Vunerability_Scanner/starttask.py

@@ -0,0 +1,67 @@
+import csv
+from gvm.connections import TLSConnection
+from gvm.protocols.gmp import Gmp
+from gvm.transforms import EtreeTransform
+import os
+
+# Set up data directory
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.abspath(os.path.join(BASE_DIR, "..", "data"))
+os.makedirs(DATA_DIR, exist_ok=True)
+
+# OpenVAS Configuration
+OPENVAS_HOST = "localhost"
+OPENVAS_PORT = 9390
+USERNAME = "admin"
+PASSWORD = "admin"
+
+# CSV file
+TASK_ID_CSV = os.path.join(DATA_DIR, "task_id.csv")
+
+
+def start_task(gmp, task_id):
+    """
+    Start a task in OpenVAS.
+    """
+    try:
+        gmp.start_task(task_id=task_id)
+        print(f"Started task with ID: {task_id}")
+    except Exception as e:
+        print(f"Failed to start task with ID {task_id}. Error: {e}")
+
+
+def read_csv_to_task_list(csv_file):
+    """
+    Read the CSV file and extract task IDs into a list.
+    """
+    task_list = []
+    with open(csv_file, newline="") as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            task_list.append(row["Task ID"])
+    return task_list
+
+
+def main():
+    connection = TLSConnection(hostname=OPENVAS_HOST, port=OPENVAS_PORT)
+    with Gmp(connection=connection, transform=EtreeTransform()) as gmp:
+        # Authenticate with OpenVAS
+        gmp.authenticate(username=USERNAME, password=PASSWORD)
+        print("Authenticated with OpenVAS")
+
+        # Read task IDs from the task_id.csv file
+        task_list = read_csv_to_task_list(TASK_ID_CSV)
+        if not task_list:
+            print("No task IDs found in the CSV file. Exiting.")
+            return
+
+        print(f"Found {len(task_list)} tasks to start.")
+
+        # Start each task
+        for task_id in task_list:
+            start_task(gmp, task_id)
+
+
+if __name__ == "__main__":
+    main()
+

Scanner/Vunerability_Scanner/taskmaker.py

@@ -0,0 +1,140 @@
+import csv
+from gvm.connections import TLSConnection
+from gvm.protocols.gmp import Gmp
+from gvm.transforms import EtreeTransform
+import os
+
+# OpenVAS Configuration
+OPENVAS_HOST = "localhost"
+OPENVAS_PORT = 9390
+USERNAME = "admin"
+PASSWORD = "admin"
+
+# Set up data directory
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.abspath(os.path.join(BASE_DIR, "..", "data"))
+os.makedirs(DATA_DIR, exist_ok=True)
+
+# CSV files
+TARGET_ID_CSV = os.path.join(DATA_DIR, "target_id.csv")
+TASK_ID_CSV = os.path.join(DATA_DIR, "task_id.csv")
+
+
+def get_scan_config_id(gmp):
+    """
+    Retrieve the ID of the 'Full and Fast' scan configuration.
+    """
+    scan_configs = gmp.get_scan_configs()
+    for config in scan_configs.findall("config"):
+        if config.find("name").text == "Full and fast":
+            config_id = config.get("id")
+            print(f"'Full and Fast' scan configuration found with ID: {config_id}")
+            return config_id
+    print("Failed to find 'Full and Fast' scan configuration.")
+    return None
+
+
+def get_scanner_id(gmp):
+    """
+    Retrieve the ID of the default scanner.
+    """
+    scanners = gmp.get_scanners()
+    for scanner in scanners.findall("scanner"):
+        if "OpenVAS Default" in scanner.find("name").text:
+            scanner_id = scanner.get("id")
+            print(f"'OpenVAS Default' scanner found with ID: {scanner_id}")
+            return scanner_id
+    print("Failed to find 'OpenVAS Default' scanner.")
+    return None
+
+
+
+def read_csv_to_target_list(csv_file):
+    """
+    Read the CSV file and extract target IDs into a list.
+    """
+    target_list = []
+    with open(csv_file, newline="") as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            target_list.append(row["Target ID"])
+    return target_list
+
+def save_task_id_to_csv(target_id, task_id):
+    """
+    Save the task ID to the task_id.csv file.
+    """
+    with open(TASK_ID_CSV, "a", newline="") as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerow([target_id, task_id])
+    print(f"Saved task ID {task_id} for target ID {target_id} to {TASK_ID_CSV}")
+
+
+def create_task(gmp, task_name, target_id, scan_config_id, scanner_id):
+    """
+    Create a task in OpenVAS.
+    """
+    response = gmp.create_task(
+        name=task_name,
+        config_id=scan_config_id,
+        target_id=target_id,
+        scanner_id=scanner_id
+    )
+    task_id = response.get("id")
+    if task_id:
+        print(f"Created task '{task_name}' for target ID '{target_id}' with ID: {task_id}")
+    else:
+        print(f"Failed to create task for target ID {target_id}. Check logs.")
+    return task_id
+
+
+def main():
+    connection = TLSConnection(hostname=OPENVAS_HOST, port=OPENVAS_PORT)
+    with Gmp(connection=connection, transform=EtreeTransform()) as gmp:
+        # Authenticate with OpenVAS
+        gmp.authenticate(username=USERNAME, password=PASSWORD)
+        print("Authenticated with OpenVAS")
+
+        # Get the scan configuration ID
+        scan_config_id = get_scan_config_id(gmp)
+        if not scan_config_id:
+            print("Failed to retrieve a valid scan configuration. Exiting.")
+            return
+
+        # Get the scanner ID
+        scanner_id = get_scanner_id(gmp)
+        if not scanner_id:
+            print("Failed to retrieve a valid scanner. Exiting.")
+            return
+
+        # Read target IDs from the target_id.csv file
+        target_list = read_csv_to_target_list(TARGET_ID_CSV)
+        if not target_list:
+            print("No target IDs found in the CSV file. Exiting.")
+            return
+
+        print(f"Found {len(target_list)} targets to create tasks for.")
+
+        # Process each target
+        for target_id in target_list:
+            print(f"Processing target ID: {target_id}")
+
+            # Create task for the target
+            task_name = f"Task for Target {target_id}"
+            task_id = create_task(gmp, task_name, target_id, scan_config_id, scanner_id)
+            if task_id:
+                save_task_id_to_csv(target_id, task_id)
+            else:
+                print(f"Failed to create task for target ID {target_id}. Continuing.")
+
+
+if __name__ == "__main__":
+    # Ensure the task_id.csv file exists with headers
+    try:
+        with open(TASK_ID_CSV, "x", newline="") as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerow(["Target ID", "Task ID"])  # Write headers if the file doesn't exist
+    except FileExistsError:
+        pass  # File already exists, no need to create
+
+    main()

Scanner/WebApp/webapp.py

@@ -0,0 +1,446 @@
+import dash
+from dash import dcc, html, dash_table
+from dash.dependencies import Input, Output, State, ALL
+import pandas as pd
+from datetime import datetime as dt
+import plotly.express as px
+import plotly.graph_objs as go
+import os
+
+
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.abspath(os.path.join(BASE_DIR, "..", "data"))
+
+detailed_scan_csv = os.path.join(DATA_DIR, "detailed_scan_results.csv")
+openvas_csv = os.path.join(DATA_DIR, "openvasscan.csv")
+
+# Load and prepare the dataset
+df = pd.read_csv(detailed_scan_csv)
+vulnerability_data = pd.read_csv(openvas_csv)
+
+# Preparing grouped data
+grouped_data = vulnerability_data.groupby(['IP', 'NVT Name', 'Severity']).first().reset_index()
+grouped_data['Details'] = grouped_data.apply(lambda row: f"CVSS: {row['CVSS']}\nSeverity: {row['Severity']}\nSummary: {row['Summary']}\nSolution Type: {row['Solution Type']}", axis=1)
+
+# List of unique IPs for the dropdown
+unique_ips = vulnerability_data['IP'].unique().tolist()
+unique_ips.insert(0, 'All')
+
+# Convert Timestamp to datetime and sort
+df['Timestamp'] = pd.to_datetime(df['Timestamp'])
+df.sort_values('Timestamp', inplace=True)
+
+# Extract unique timestamps
+unique_timestamps = df['Timestamp'].unique()
+
+# Prepare data for the timeline graph, grouped by day
+df['Date'] = df['Timestamp'].dt.date
+ip_count_over_time = df.groupby('Date')['IP'].nunique().reset_index()
+ip_count_over_time.columns = ['Date', 'IP_Count']
+
+# Create the Plotly graph
+timeline_fig = px.line(ip_count_over_time, x='Date', y='IP_Count', title='Number of IPs Over Time')
+timeline_fig.update_layout(
+    xaxis_title="Date",
+    yaxis_title="IP Count"
+)
+
+# Initialize the Dash app
+app = dash.Dash(__name__)
+
+# Convert timestamps to strings for slider display
+timestamp_options = [{'label': str(ts), 'value': ts} for ts in df['Timestamp'].unique()]
+timestamp_values = [ts.value for ts in df['Timestamp']]
+
+def style_status_badge(status):
+    emoji_map = {
+        'Added': '🟩',
+        'Removed': '🟥',
+        'Still Active': '⚪'
+    }
+    return f"{emoji_map.get(status, '⬜')} {status}"
+
+
+app.layout = html.Div([
+    dcc.Tabs(id="tabs", children=[
+        dcc.Tab(label='Overview', children=[
+            html.Div([
+                dcc.RangeSlider(
+                    id='time-range-slider',
+                    min=0,
+                    max=len(unique_timestamps) - 1,
+                    value=[0, len(unique_timestamps) - 1],
+                    marks={i: {'label': str(ts)[:10]} for i, ts in enumerate(unique_timestamps)},
+                    step=1,
+                    allowCross=False
+                ),
+                dash_table.DataTable(
+                    id='table',
+                    columns=[{"name": i, "id": i, "presentation": "markdown"} if i == "Status" else {"name": i, "id": i} 
+                    for i in df.columns
+                    ] + [{"name": "Status", "id": "Status", "presentation": "markdown"}],
+                    sort_action='native',
+                    filter_action='native',
+                    style_table={'overflowX': 'auto'},
+                    style_data_conditional=[{'if': {'column_id': 'Status'}, 'textAlign': 'center', 'width': '120px'}]
+                ),
+                html.Div([
+                    dcc.Graph(
+                        id='timeline-graph',
+                        figure=timeline_fig
+                    ),
+                    dcc.Graph(id='open-ports-bar-chart')
+                ], style={'display': 'flex', 'flex-direction': 'row'}),
+                html.Div([
+                    dcc.Graph(id='severity-pie-chart')
+                    
+                ], style={'display': 'flex', 'flex-direction': 'row'}),
+                html.Div([
+                    dcc.Graph(id='ip-change-bar-chart'),
+                    dash_table.DataTable(
+                        id='ip-change-table',
+                        columns=[
+                            {"name": "IP", "id": "IP"},
+                            {"name": "Status", "id": "Status"}
+                        ],
+                        sort_action='native',
+                        filter_action='native',
+                        style_table={'overflowX': 'auto'}
+                    )
+                ], style={'display': 'flex', 'flex-direction': 'row'}),
+                html.Div(id='summary-section', style={'padding': '20px'})
+            ])
+        ]),
+        dcc.Tab(label='Vulnerability Analysis', children=[
+            html.Div([
+                dcc.Dropdown(
+                    id='severity-dropdown',
+                    options=[{'label': s, 'value': s} for s in ['All', 'High', 'Medium', 'Low']],
+                    value='All'
+                ),
+                dcc.Dropdown(
+                    id='ip-dropdown',
+                    options=[{'label': ip, 'value': ip} for ip in unique_ips],
+                    value='All'
+                ),
+                dcc.Graph(id='vulnerability-treemap'),
+                html.Div(id='details-and-ip-output'),
+                html.Div(id='clicked-ip', style={'display': 'none'})
+            ])
+        ]),
+        dcc.Tab(label='Port Heatmap', children=[  
+            html.Div([
+                dcc.Graph(id='ip-port-heatmap', style={'height': '700px', 'width': '100%'}),
+                html.Div([
+                html.P("🟦 = Port is Open"),
+                html.P("⬜ = Port is Closed"),
+                html.P("Each row represents a Host (IP), and each column is a Port."),
+                html.P("This heatmap shows which ports are open on each host at the selected time.")
+            ], style={
+                'padding': '10px',
+                'backgroundColor': '#f9f9f9',
+                'border': '1px solid #ccc',
+                'marginTop': '10px',
+                'borderRadius': '5px'
+            })
+            ])
+
+        ])
+    ])
+])
+
+@app.callback(
+    [Output('table', 'data'),
+     Output('table', 'style_data_conditional'),
+     Output('timeline-graph', 'figure'),
+     Output('open-ports-bar-chart', 'figure'),
+     Output('severity-pie-chart', 'figure'),
+     Output('ip-port-heatmap', 'figure'),
+     Output('ip-change-bar-chart', 'figure'),
+     Output('ip-change-table', 'data'),
+     Output('summary-section', 'children')],
+    [Input('time-range-slider', 'value')]
+)
+def update_overview_tab(time_range):
+    start_index, end_index = time_range
+    start_timestamp = unique_timestamps[start_index]
+    end_timestamp = unique_timestamps[end_index]
+
+    # Filter data within the selected time range
+    filtered_df = df[(df['Timestamp'] >= start_timestamp) & (df['Timestamp'] <= end_timestamp)].copy()
+
+    # Update table
+    filtered_df_selected = filtered_df.copy()
+
+
+    # Determine IPs in the time range
+    #all_ips = set(filtered_df['IP'])
+    #status_dict = {ip: 'Within Range' for ip in all_ips}
+
+    # Assign badge-style labels using style_status_badge
+    #filtered_df_selected['Status'] = filtered_df_selected['IP'].map(status_dict).fillna('Unknown')
+   # filtered_df_selected['Status'] = filtered_df_selected['Status'].apply(style_status_badge)
+    # Determine IPs in the time range
+    all_ips = set(filtered_df['IP'])
+
+    # Get previous IP set
+    if start_index > 0:
+        prev_timestamp = unique_timestamps[start_index - 1]
+    else:
+        prev_timestamp = start_timestamp
+
+    prev_ips = set(df[df['Timestamp'] == prev_timestamp]['IP'])
+    new_ips = all_ips - prev_ips
+    removed_ips = prev_ips - all_ips
+    existing_ips = all_ips.intersection(prev_ips)
+
+    # Add dummy rows for removed IPs (with NaNs or placeholders)
+    removed_rows = pd.DataFrame({
+        "IP": list(removed_ips),
+        "Hostname": "", "MAC Address": "", "Protocol": "", "Port": "", "Name": "",
+        "State": "", "Product": "", "Version": "", "Extra Info": "",
+        "Timestamp": pd.NaT, "Date": None
+    })
+    filtered_df_selected = pd.concat([filtered_df_selected, removed_rows], ignore_index=True)
+
+    
+
+    # Build status dictionary for badges
+    status_dict = {}
+    for ip in new_ips:
+        status_dict[ip] = 'Added'
+    for ip in removed_ips:
+        status_dict[ip] = 'Removed'
+    for ip in existing_ips:
+        status_dict[ip] = 'Still Active'
+
+    # Assign and badge
+    filtered_df_selected['Status'] = filtered_df_selected['IP'].map(status_dict).fillna('Unknown')
+    filtered_df_selected['Status'] = filtered_df_selected['Status'].apply(style_status_badge)
+
+    # Apply conditional formatting based on the 'Status' column
+    style = [
+    {
+        'if': {
+            'filter_query': '{Status} = "Added"',
+        },
+        'borderLeft': '4px solid green',
+        'backgroundColor': '#eaf7ea'  # very light green background
+    },
+    {
+        'if': {
+            'filter_query': '{Status} = "Removed"',
+        },
+        'borderLeft': '4px solid red',
+        'backgroundColor': '#fcebea'  # very light red background
+    },
+    {
+        'if': {
+            'filter_query': '{Status} = "Still Active"',
+        },
+        'borderLeft': '4px solid lightgray'
+    }
+]
+
+    # Update timeline graph, grouped by day
+    filtered_df['Date'] = filtered_df['Timestamp'].dt.date
+    ip_count_over_time = filtered_df.groupby('Date')['IP'].nunique().reset_index()
+    ip_count_over_time.columns = ['Date', 'IP_Count']
+    timeline_fig = px.line(ip_count_over_time, x='Date', y='IP_Count', title='Number of IPs Over Time')
+    timeline_fig.update_layout(
+        xaxis_title="Date",
+        yaxis_title="IP Count"
+    )
+
+    # Open ports bar chart
+    open_ports_count = filtered_df['Port'].value_counts().reset_index()
+    open_ports_count.columns = ['Port', 'Count']
+    open_ports_bar_chart = px.bar(open_ports_count, x='Port', y='Count', title='Distribution of Open Ports')
+    open_ports_bar_chart.update_layout(
+        xaxis_title="Port",
+        yaxis_title="Count"
+    )
+    open_ports_bar_chart.update_traces(marker_color='blue', marker_line_color='darkblue', marker_line_width=1.5, opacity=0.8)
+
+    # Severity pie chart
+    severity_count = vulnerability_data['Severity'].value_counts().reset_index()
+    severity_count.columns = ['Severity', 'Count']
+    severity_pie_chart = px.pie(severity_count, names='Severity', values='Count', title='Severity Distribution')
+
+    #  IP-Port Heatmap with Fixed Port Range and Binary Open/Closed
+
+    # Define all possible ports you want to show (e.g. top 1024)
+    # Only include ports that were actually scanned, but sorted
+    all_ports = sorted(filtered_df['Port'].dropna().astype(int).unique().tolist())
+
+    all_ips = set(filtered_df['IP'])
+
+
+
+    heatmap_df = (
+        filtered_df[["IP", "Port"]]
+        .dropna()
+        .assign(value=1)
+        .pivot_table(index="IP", columns="Port", values="value", fill_value=0)
+    )
+    heatmap_df.columns = heatmap_df.columns.astype(int)
+    heatmap_df = heatmap_df.sort_index(axis=1)
+
+    hover_text = [
+    [f"IP: {ip}<br>Port: {port}<br>Status: {'Open' if val == 1 else 'Closed'}"
+     for port, val in zip(heatmap_df.columns, row)]
+    for ip, row in zip(heatmap_df.index, heatmap_df.values)
+    ]
+
+
+    # Generate heatmap
+    ip_port_heatmap = go.Figure(data=go.Heatmap(
+        z=heatmap_df.values,
+        x=heatmap_df.columns,
+        y=heatmap_df.index,
+        text=hover_text,
+        hoverinfo='text',
+        colorscale=[[0, 'white'], [1, 'darkblue']],
+        zmin=0,
+        zmax=1,
+        zsmooth=False,
+        colorbar=dict(
+            title='Port Status',
+            tickvals=[0, 1],
+            ticktext=['Closed (White)', 'Open (Blue)']
+        )
+    ))
+    ip_port_heatmap.update_layout(
+        title='Binary Heatmap - Which Ports Are Open on Which Hosts',
+        xaxis_title='Port',
+        yaxis_title='IP',
+        height=600
+    )
+
+
+    # Determine IPs added and removed
+    if start_index > 0:
+        prev_timestamp = unique_timestamps[start_index - 1]
+    else:
+        prev_timestamp = start_timestamp
+
+    prev_ips = set(df[df['Timestamp'] == prev_timestamp]['IP'])
+    new_ips = all_ips - prev_ips
+    removed_ips = prev_ips - all_ips
+    existing_ips = all_ips.intersection(prev_ips)
+
+    # IP change table
+    ip_change_data = []
+    for ip in new_ips:
+        ip_change_data.append({"IP": ip, "Status": "Added"})
+    for ip in removed_ips:
+        ip_change_data.append({"IP": ip, "Status": "Removed"})
+    for ip in existing_ips:
+        ip_change_data.append({"IP": ip, "Status": "Still Active"})
+
+    # IP change bar chart
+    ip_change_summary = {
+        "Added": len(new_ips),
+        "Removed": len(removed_ips),
+        "Still Active": len(existing_ips)
+    }
+    ip_change_bar_chart = px.bar(
+        x=list(ip_change_summary.keys()),
+        y=list(ip_change_summary.values()),
+        title="IP Changes Summary"
+    )
+    ip_change_bar_chart.update_layout(
+        xaxis_title="Change Type",
+        yaxis_title="Count"
+    )
+    ip_change_bar_chart.update_traces(marker_color='purple', marker_line_color='darkblue', marker_line_width=1.5, opacity=0.8)
+
+    # Summary section
+    total_unique_ips = len(df['IP'].unique())
+    total_vulnerabilities = len(vulnerability_data)
+    most_common_ports = filtered_df['Port'].value_counts().head(5).to_dict()
+    most_dangerous_vulnerability = vulnerability_data.loc[vulnerability_data['CVSS'].idxmax()]
+    most_common_vulnerability = vulnerability_data['NVT Name'].value_counts().idxmax()
+    most_common_ip = df['IP'].value_counts().idxmax()
+    average_cvss_score = vulnerability_data['CVSS'].mean()
+    ips_with_most_vulnerabilities = vulnerability_data['IP'].value_counts().head(5).to_dict()
+    
+    summary_content = html.Div([
+        html.H3("Summary of Interesting Data"),
+        html.P(f"Total unique IPs: {total_unique_ips}"),
+        html.P(f"Total vulnerabilities recorded: {total_vulnerabilities}"),
+        html.P(f"Most dangerous vulnerability (highest CVSS score): {most_dangerous_vulnerability['NVT Name']} with CVSS score {most_dangerous_vulnerability['CVSS']}"),
+        html.P(f"Most common vulnerability: {most_common_vulnerability}"),
+        html.P(f"Most common IP: {most_common_ip}"),
+        html.P(f"Average CVSS score: {average_cvss_score:.2f}"),
+        html.H4("Most Common Ports:"),
+        html.Ul([html.Li(f"Port {port}: {count} times") for port, count in most_common_ports.items()]),
+        html.H4("IPs with the Most Vulnerabilities:"),
+        html.Ul([html.Li(f"IP {ip}: {count} vulnerabilities") for ip, count in ips_with_most_vulnerabilities.items()])
+    ])
+
+    return (filtered_df_selected.to_dict('records'), style, timeline_fig, open_ports_bar_chart, severity_pie_chart,
+            ip_port_heatmap, ip_change_bar_chart, ip_change_data, summary_content)
+
+@app.callback(
+    [Output('vulnerability-treemap', 'figure'),
+     Output('clicked-ip', 'children')],
+    [Input('severity-dropdown', 'value'),
+     Input('ip-dropdown', 'value'),
+     Input({'type': 'dynamic-ip', 'index': ALL}, 'n_clicks')],
+    [State({'type': 'dynamic-ip', 'index': ALL}, 'index')]
+)
+def update_treemap(selected_severity, selected_ip, n_clicks, ip_indices):
+    ctx = dash.callback_context
+    triggered_id = ctx.triggered[0]['prop_id'] if ctx.triggered else None
+    # Determine if the callback was triggered by a related IP link click
+    if ctx.triggered and 'dynamic-ip' in ctx.triggered[0]['prop_id']:
+        # Extract clicked IP
+        triggered_info = ctx.triggered[0]
+        button_id = triggered_info['prop_id'].split('}.')[0] + '}'
+        clicked_ip = json.loads(button_id)['index']
+    else:
+        clicked_ip = None
+    
+    # Filter data based on severity, dropdown IP, or clicked related IP
+    filtered_data = grouped_data.copy()
+    filtered_data['CVSS'] = filtered_data['CVSS'].fillna(0)
+    if selected_severity != 'All':
+        filtered_data = filtered_data[filtered_data['Severity'] == selected_severity]
+    if selected_ip != 'All':
+        filtered_data = filtered_data[filtered_data['IP'] == selected_ip]
+    if clicked_ip:
+        filtered_data = filtered_data[filtered_data['IP'] == clicked_ip]
+    filtered_data = filtered_data[filtered_data['CVSS'] > 0]
+
+    fig = px.treemap(
+        filtered_data,
+        path=['IP', 'NVT Name'],
+        values='CVSS',
+        color='CVSS',
+        color_continuous_scale='reds',
+        hover_data=['Details']
+    )
+    return fig, ""  # Reset clicked-ip because of bug
+
+# Callback to display details and related IPs
+@app.callback(
+    Output('details-and-ip-output', 'children'),
+    [Input('vulnerability-treemap', 'clickData')]
+)
+def display_details_and_ips(clickData):
+    if clickData is not None:
+        clicked_vuln = clickData['points'][0]['label'].split('<br>')[0]
+        details = clickData['points'][0]['customdata'][0]
+        matching_ips = vulnerability_data[vulnerability_data['NVT Name'] == clicked_vuln]['IP'].unique()
+
+        return html.Div([
+            html.Pre(f'Details of Selected Vulnerability:\n{details}'),
+            html.H4("Related IPs with the same vulnerability:"),
+            html.Div([html.A(ip, href='#', id={'type': 'dynamic-ip', 'index': ip}, style={'marginRight': '10px', 'cursor': 'pointer'}) for ip in matching_ips])
+        ])
+    return 'Click on a vulnerability to see details and related IPs.'
+
+if __name__ == '__main__':
+    app.run(debug=True)

Scanner/openvas-docker/docker-compose.yml

@@ -0,0 +1,17 @@
+version: '3.8'
+
+services:
+  openvas:
+    image: immauss/openvas
+    container_name: openvas
+    restart: unless-stopped
+    ports:
+      - "9390:9390"   # GMP (Greenbone Management Protocol) for GVM Tools
+      - "8080:9392"   # Web UI Openvas
+    volumes:
+      - gvm-data:/data
+    shm_size: '2gb'
+
+volumes:
+  gvm-data:
+