codeaudit 0.5.3__py3-none-any.whl

codeaudit/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2025-present Maikel Mardjan <mike@bm-support.org>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+__version__ = "0.5.3"

codeaudit/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2025-present Maikel Mardjan <mike@bm-support.org>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+from . __about__ import __version__

codeaudit/altairplots.py

@@ -0,0 +1,54 @@
+"""
+License GPLv3 or higher.
+
+(C) 2025 Created by Maikel Mardjan - https://nocomplexity.com/
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+
+Altair Plotting functions for codeaudit
+"""
+
+import altair as alt
+import pandas as pd
+
+
+def make_chart(y_field, df):
+    """Function to create a single bar chart with red and grey bars."""
+    
+    # Calculate the median (or use any other threshold if needed)
+    threshold = df[y_field].median()
+
+    # Add a column for color condition
+    df = df.copy()
+    df['color'] = df[y_field].apply(lambda val: 'red' if val > threshold else 'grey')
+
+    chart = alt.Chart(df).mark_bar().encode(
+        x=alt.X('FileName:N', sort=None, title='File Name'),            
+        y=alt.Y(f'{y_field}:Q', title=y_field),
+        color=alt.Color('color:N', scale=alt.Scale(domain=['red', 'grey'], range=['#d62728', '#7f7f7f']), legend=None),
+        tooltip=['FileName', y_field]
+    ).properties(
+        width=400,
+        height=400,
+        title=y_field
+    )
+    return chart
+
+def multi_bar_chart(df):
+    """Creates a multi bar chart for all relevant columns"""          
+
+    # List of metrics to chart
+    metrics = [
+        "Number_Of_Lines", "AST_Nodes", "Modules",
+        "Functions", "Comment_Lines", "Complexity_Score"
+    ]
+    rows = [alt.hconcat(*[make_chart(metric,df) for metric in metrics[i:i+2]])   for i in range(0, len(metrics), 2)]
+
+    # Stack the rows vertically
+    multi_chart = alt.vconcat(*rows)
+
+    return multi_chart

codeaudit/checkmodules.py

@@ -0,0 +1,103 @@
+"""
+License GPLv3 or higher.
+
+(C) 2025 Created by Maikel Mardjan - https://nocomplexity.com/
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+
+
+Checking imported Python modules functions for codeaudit
+"""
+
+import ast
+import sys
+import json
+import urllib.request
+
+
+def get_imported_modules(source_code):
+    tree = ast.parse(source_code)
+    imported_modules = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                # e.g., import os -> os
+                imported_modules.append(alias.name)
+        elif isinstance(node, ast.ImportFrom):
+            # e.g., from os import path -> os
+            module_name = node.module
+            if module_name:
+                imported_modules.append(module_name)
+    imported_modules = list(set(imported_modules)) # to make the list with unique values only!
+    # distinguish imported modules vs Standard Library
+    standard_modules = get_standard_library_modules()
+    core_modules = []
+    external_modules = []
+    for module in imported_modules:
+        top_level_module_name = module.split('.')[0]
+        if top_level_module_name in standard_modules:
+            core_modules.append(module)
+        else:
+            external_modules.append(module)
+    result = {'core_modules' : sorted(core_modules) ,
+              'imported_modules': sorted(external_modules)}
+    return result
+
+
+def get_standard_library_modules():
+    """works only Python 3.10+ or higher!"""
+    names = []
+    if hasattr(sys, 'stdlib_module_names'):
+        core_modules = sorted(list(sys.stdlib_module_names))        
+        for module_name in core_modules:
+            if not module_name.startswith('_'):
+                names.append(module_name)
+    return names
+
+
+def query_osv(package_name, ecosystem="PyPI"):
+    """MVP version to check imported module on vulnerabilities on osv db """
+    url = "https://api.osv.dev/v1/query"
+    headers = {
+        "Content-Type": "application/json"
+    }
+    data = {
+        "version": '', #no version needed for this tool
+        "package": {
+            "name": package_name,
+            "ecosystem": ecosystem
+        }
+    }
+
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(data).encode("utf-8"),
+        headers=headers,
+        method="POST"
+    )
+
+    with urllib.request.urlopen(request) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def extract_vuln_info(data):
+    results = []
+    for vuln in data.get("vulns", []):
+        info = {
+            "id": vuln.get("id"),
+            "details": vuln.get("details"),
+            "aliases": vuln.get("aliases", [])
+        }
+        results.append(info)
+    return results
+
+def check_module_on_vuln(module):
+    """Retrieves vuln info for external modules using osv-db"""        
+    result = query_osv(module)
+    vulnerability_info = extract_vuln_info(result)
+    return vulnerability_info

codeaudit/codeaudit.py

@@ -0,0 +1,79 @@
+"""
+License GPLv3 or higher.
+
+(C) 2025 Created by Maikel Mardjan - https://nocomplexity.com/
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+
+
+CLI functions for codeaudit
+"""
+import fire  # for working CLI with this PoC-thing (The Google way)
+import sys
+from codeaudit import __version__
+from codeaudit.reporting import overview_report ,report_module_information ,file_scan_report , directory_scan_report , report_implemented_tests
+
+codeaudit_ascii_art=r"""
+--------------------------------------------------
+   _____          _                      _ _ _   
+  / ____|        | |                    | (_) |  
+ | |     ___   __| | ___  __ _ _   _  __| |_| |_ 
+ | |    / _ \ / _` |/ _ \/ _` | | | |/ _` | | __|
+ | |___| (_) | (_| |  __/ (_| | |_| | (_| | | |_ 
+  \_____\___/ \__,_|\___|\__,_|\__,_|\__,_|_|\__|
+--------------------------------------------------
+"""
+     
+
+def display_version():
+    """Prints the module version. Use [-v] [--v] [-version] or [--version]."""
+    print(f"version: {__version__}")
+
+
+def display_help():
+    """Shows detailed help for using codeaudit tool."""    
+    print(codeaudit_ascii_art)
+    print("Codeaudit - Modern Python source code analyzer based on distrust.\n")
+    print("Commands to evaluate Python source code:")
+    print('Usage: codeaudit COMMAND [PATH or FILE]  [OUTPUTFILE] \n')
+    print('Depending on the command, a directory or file name must be specified. The output is a static HTML file to be examined in a browser. Specifying a name for the output file is optional.\n')
+    print('Commands:')
+    commands = ["overview", "modulescan", "filescan", "directoryscan","checks","version"]  # commands on CLI
+    functions = [overview_report, report_module_information, file_scan_report, directory_scan_report, report_implemented_tests,display_version]  # Related functions relevant for help
+    for command, function in zip(commands, functions):
+        docstring = function.__doc__.strip().split('\n')[0] or ""  
+        summary = docstring.split("\n", 1)[0]
+        print(f"  {command:<20} {summary}")        
+    print("\nUse the Codeaudit documentation to check the security of Python programs and make your Python programs more secure!\nCheck https://simplifysecurity.nocomplexity.com/ \n")
+
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] in ("-v", "--v", "--version", "-version"):
+        display_version()
+    elif len(sys.argv) > 1 and sys.argv[1] in ("-help", "-?", "--help", "-h"):
+        display_help()
+    elif len(sys.argv) == 1:
+        display_help()
+    else:
+        fire.Fire(
+            {
+                "overview": overview_report,               
+                "modulescan": report_module_information,
+                "filescan" : file_scan_report,
+                "directoryscan" : directory_scan_report,
+                "checks" : report_implemented_tests,
+                "-help": display_help,
+            }
+        )
+
+
+if __name__ == "__main__":
+    main()
+
+                                            
+                                                 
+

codeaudit/complexitycheck.py

@@ -0,0 +1,107 @@
+"""
+License GPLv3 or higher.
+
+(C) 2025 Created by Maikel Mardjan - https://nocomplexity.com/
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+
+Simple Cyclomatic Complexity check for Python source files
+See the docs for in-depth and why this is a simple way , but good enough!
+"""
+
+import ast
+import warnings
+
+class ComplexityVisitor(ast.NodeVisitor):
+    def __init__(self):
+        self.complexity = 1  # Start with 1 for the entry point
+
+    def visit_If(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_For(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_While(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_Try(self, node):
+        self.complexity += 1 # For the try block
+        self.generic_visit(node)
+
+    def visit_ExceptHandler(self, node):
+        self.complexity += 1 # For each except clause
+        self.generic_visit(node)
+
+    def visit_With(self, node):
+        self.complexity += 1 # For 'with' statements
+        self.generic_visit(node)
+
+    def visit_BoolOp(self, node):
+        # Count 'and' and 'or' operators
+        # Each 'and' or 'or' introduces a new predicate
+        self.complexity += (len(node.values) - 1)
+        self.generic_visit(node)
+    
+    def visit_Match(self, node):
+        # A 'match' statement itself adds to complexity
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_MatchCase(self, node):
+        # Each 'case' in a match statement is a distinct path
+        # Note: The 'visit_Match' already adds 1. Each subsequent 'MatchCase'
+        # For simplicity and aligning with common CC interpretations where each distinct
+        # path adds 1, we'll increment for each MatchCase.
+        # So count each case as a separate branch point from the 'match' entry.
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_Assert(self, node):
+        # Assert statements introduce a potential exit point (branch)
+        self.complexity += 1
+        self.generic_visit(node)
+
+
+def calculate_complexity(code):
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=SyntaxWarning)
+        tree = ast.parse(code)
+
+    visitor = ComplexityVisitor()
+    visitor.visit(tree)
+    return visitor.complexity
+
+
+def count_static_warnings_in_file(file_path):
+    """
+    Parses a Python source file using AST and counts the number of warnings raised (e.g., SyntaxWarning).
+
+    Args:
+        file_path (str): Path to the Python source file.
+
+    Returns:
+        int: Number of static warnings detected during parsing.
+             Returns -1 if the file cannot be read or parsed.
+    """
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            source = f.read()
+
+        with warnings.catch_warnings(record=True) as caught_warnings:
+            warnings.simplefilter("always")  # Capture all warnings
+            ast.parse(source, filename=file_path)
+        
+        result = { 'warnings' : len(caught_warnings)} 
+
+        return result
+
+    except (SyntaxError, UnicodeDecodeError, ValueError):
+        return -1

codeaudit/data/sastchecks.csv

@@ -0,0 +1,59 @@
+name,construct,severity,info
+Check on assert,assert,Low,Assertions are for debugging and development. Misuse can lead to security vulnerabilities.
+Binding All Interfaces,s.bind,Medium,Network sockets require additional measurements.
+Check for chmod,os.chmod,High,Operating System calls can have a  security impact and should be inspected in detail.
+Directory Creation,os.makedirs,Low,Operating System calls can have a  security impact and should be inspected in detail.
+Directory Creation,os.mkdir,Low,Operating System calls can have a  security impact and should be inspected in detail.
+Directory Creation,os.mkfifo,Low,Operating System calls can have a  security impact and should be inspected in detail.
+Directory Creation,os.mknod,Low,Operating System calls can have a  security impact and should be inspected in detail.
+Directory Creation,os.makedev,Low,Operating System calls can have a  security impact and should be inspected in detail.
+OS System call - Fork a child process,os.fork,Low,"On macOS use of this function is unsafe when mixed with using higher-level system APIs, and that includes using urllib.request."
+Check on eval usuage,eval,High,This function can executes arbitrary code.
+Check on input statement,input,Low,Use of input requires strict sanitizing and validation.
+Exception Handling,pass,Low,Too broad exception handling risk when not used correctly.
+Exception Handling- Continue statement,continue,Low,Too broad exception handling risk when not used correctly.
+Built-in Functions: Check for exec usuage.,exec,High,This built-in function can execute code you do not want and/or aware of. So check and validate if it is used correct.
+Built-in Functions: Check on compile usuage.,compile,High,It is possible to crash the Python interpreter when using this function.
+Hash Check - md5,hashlib.md5,High,Use of insecure hashing algorithms detected.
+Hash Check -sha1,hashlib.sha1,High,Use of insecure hashing algorithms detected.
+Logging - configuration ,logging.config,Low,Potential security issues can arise with parsing objects and incorrect sanitizing.
+Pickle use,pickle.loads,High,unpickling will import any class or function that it finds in the pickle data
+Pickle use,pickle.load,High,unpickling will import any class or function that it finds in the pickle data
+OS  - direct calls,os.system,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - execl,os.execl,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - execle,os.execle,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - execlp,os.execlp,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - execlpe,os.execlpe,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - execv,os.execv,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - execve,os.execve,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - execvp,os.execvp,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - execvpe,os.execvpe,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS  - popen,os.popen,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS Access,os.access,High,Operating System calls can have a  security impact and should be inspected in detail.
+OS Interfaces,os.write,Low,os.write can cause availability issues if not done correct.
+OS Interfaces,os.writev,Low,os.writev can cause availability issues if not done correct.
+OS Interfaces,os.forkpty,Low,Use of forkpty can be unsafe when used on MacOS.
+OS Interface,os.read,Low,"When files can be read from , they can be transfered to some place you do not want."
+Marshal,marshal.loads,High,The marshal module is not intended to be secure against erroneous or maliciously constructed data. 
+Marshal,marshal.load,High,The marshal module is not intended to be secure against erroneous or maliciously constructed data. 
+Subprocesses - call,subprocess.call,High,Use of the subprocess module calls should be analyzed in-depth.
+Subprocesses - check_call,subprocess.check_call,High,Use of the subprocess module calls should be analyzed in-depth.
+Subprocesses - Popen,subprocess.Popen,Medium,Use of the subprocess module calls should be analyzed in-depth.
+Subprocesses - run,subprocess.run,Medium,Use of the subprocess module calls should be analyzed in-depth.
+Tarfile,tarfile.TarFile,High,Extracting files within a program should never be trusted by default. This issue is detected when the zipfile and/or tarfile module with an extraction method is used.
+Encodings,base64,Low,"Base encoding visually hides otherwise easily recognized information such as passwords, but does not provide any computational confidentiality."
+XML - client,xmlrpc.client,High,xmlrpc is vulnerable to the “decompression bomb” attack.
+XML - server,xmlrpc.server.SimpleXMLRPCServer,High,xmlrpc.server is vulnerable to the “decompression bomb” attack.
+Random numbers generation module,random.random,Low,The pseudo-random generators of this module should not be used for security purposes.
+Random numbers generation module,random.seed,Low,The pseudo-random generators of this module should not be used for security purposes.
+Shelve module,shelve.open,High,Only loading a shelve from a trusted source is secure. So check if this is the case.
+Multiprocessing ,connection.recv,High,Connection.recv() uses pickle
+Multiprocessing ,multiprocessing.connection.Connection,High,Connection.recv() uses pickle
+Zipfile,zipfile.ZipFile,High,Extracting files within a program should never be trusted by default. This issue is detected when the zipfile and/or tarfile module with an extraction method is used.
+shutil,shutil.unpack_archive,Medium,Extracting files within a program should not be trusted by default.
+shutil,shutil.copy,Medium,Information can be transfered without permission.
+shutil,shutil.copy2,Medium,Information can be transfered without permission.
+shutil,shutil.copytree,Medium,Information can be transfered without permission.
+shutil,shutil.chown,Medium,Programs should not change access rights on files they do not own.
+HTTP servers: Check on usuage.,http.server.BaseHTTPRequestHandler,High,Insecure for production use.
+HTTP servers: Check on usuage.,http.server.HTTPServer,High,Insecure for production use.

codeaudit/filehelpfunctions.py

@@ -0,0 +1,114 @@
+"""
+License GPLv3 or higher.
+
+(C) 2025 Created by Maikel Mardjan - https://nocomplexity.com/
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+
+Helper functions for files
+"""
+
+import os
+import sys
+from pathlib import Path
+import ast
+import warnings
+
+def read_in_source_file(file_path):
+    # Ensure file_path is a Path object
+    file_path = Path(file_path)
+
+    if file_path.is_dir():
+        print(
+            "Error: The given path is a directory.\nUse the function: codeaudit directoryscan\nUse codeaudit -h for help"
+        )
+        sys.exit(1)
+
+    if file_path.suffix != ".py":
+        print("Error: The given file is not a Python (.py) file.")
+        sys.exit(1)
+
+    try:
+        with file_path.open("r", encoding="utf-8") as f:
+            return f.read()
+    except Exception as e:
+        print(f"Failed to read file: {e}")
+        sys.exit(1)
+
+
+def collect_python_source_files(directory):
+    """
+    Collects all Python source files (.py) from a directory, including subdirectories,
+    while skipping directories that are hidden (start with '.') or underscore-prefixed,
+    or are in a predefined exclusion list.
+
+    Args:
+        directory (str): The path to the directory to search.
+
+    Returns:
+        list: A list of absolute paths to valid Python source files.
+    """
+    EXCLUDE_DIRS = {"docs", "docker", "dist", "tests"}    
+    python_files = []
+
+    for root, dirs, files in os.walk(directory):
+        # Filter out unwanted directories
+        dirs[:] = [
+            d for d in dirs
+            if not (
+                d.startswith(".") or d.startswith("_") or d in EXCLUDE_DIRS
+            )
+        ]
+
+        for file in files:
+            if file.endswith(".py") and not file.startswith("."):
+                full_path = os.path.join(root, file)
+                if os.path.isfile(full_path):
+                    python_files.append(os.path.abspath(full_path))
+    #check if the file can be parsed using the AST
+    final_file_list = []
+    for python_file in python_files:
+        if is_ast_parseable(python_file):
+            final_file_list.append(python_file)
+        else:
+            print(f'Error: {python_file} will be skipped due to syntax error while parsing into AST.')
+    return final_file_list
+
+
+def get_filename_from_path(file_path):
+    """
+    Extracts the file name (including extension) from a full path string.
+
+    Args:
+        file_path (str): The full path to the file.
+
+    Returns:
+        str: The file name.
+    """
+    return os.path.basename(file_path)
+
+
+def is_ast_parseable(file_path):
+    """
+    Checks whether a Python file can be parsed using the AST module.
+
+    Args:
+        file_path (str): Path to the Python source file.
+
+    Returns:
+        bool: True if the file can be parsed without syntax errors, False otherwise.
+    """
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            source = f.read()
+         
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=SyntaxWarning)
+            ast.parse(source, filename=file_path)
+        return True
+    except (SyntaxError, UnicodeDecodeError, ValueError) as e:
+        return False

codeaudit/htmlhelpfunctions.py

@@ -0,0 +1,90 @@
+"""
+License GPLv3 or higher.
+
+(C) 2025 Created by Maikel Mardjan - https://nocomplexity.com/
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+
+HTML helper functions for codeaudit
+"""
+import json
+from html import escape
+
+
+def dict_to_html(data):
+    """Creates simple HTML from a dict with values that are list:
+    Example {'core_modules': ['os', 'hashlib', 'socket', 'logging.config', 'tarfile'],
+             'imported_modules': ['linkaudit', 'pandas']}
+    """
+    html_output = ""
+
+    if not isinstance(data, dict):
+        html_output += "<p>None</p>\n"        
+        return
+
+    for key, items in data.items():
+        html_output += f"<h3>{key.capitalize()}</h3>\n<ul>\n"
+        try:
+            for item in items:
+                html_output += f"  <li>{item}</li>\n"
+        except Exception:
+            html_output += "  <li>None</li>\n"
+        html_output += "</ul>\n"
+    return html_output
+
+
+def json_to_html(json_input):
+    """
+    Takes a Python dictionary or JSON string and returns an HTML page
+    that displays the JSON in a formatted and readable way.
+    """
+    # Parse JSON string if needed
+    # Parse if input is a JSON string
+    if isinstance(json_input, str):
+        json_data = json.loads(json_input)
+    else:
+        json_data = json_input
+
+    # Pretty-printed JSON string
+    pretty_json = json.dumps(json_data, indent=2)
+
+    # Escape HTML characters for safe embedding inside <code>
+    escaped_json = escape(pretty_json)
+
+    html_output = f'<div class="json-display">{escaped_json}</div>'
+    return html_output
+
+
+def dict_list_to_html_table(data):
+    """
+    Converts a list of dictionaries to an HTML table string.
+    :param data: List[Dict] - List of dicts with the same keys.
+    :return: str - HTML table as string.
+    """
+    if not data:
+        return "<p><em>No data available</em></p>"
+
+    # Get column headers from the first dictionary
+    headers = data[0].keys()
+
+    # Start the HTML table
+    html = '<table border="1" cellpadding="5" cellspacing="0">\n'
+    html += '  <thead>\n    <tr>\n'
+    for header in headers:
+        html += f'      <th>{header}</th>\n'
+    html += '    </tr>\n  </thead>\n  <tbody>\n'
+
+    # Add rows
+    for row in data:
+        html += '    <tr>\n'
+        for header in headers:
+            html += f'      <td>{row.get(header, "")}</td>\n'
+        html += '    </tr>\n'
+
+    html += '  </tbody>\n</table>'
+
+    return html