Upload 14 files

components/ai_models.py

@@ -0,0 +1,632 @@
+import json
+import re
+from typing import Any
+from typing import Optional
+import openai
+import requests
+model_engine = "gpt-3.5-turbo-0613"
+
+
+class DNS_AI_MODEL():
+    @staticmethod
+    def BardAI(key: str, data: Any) -> str:
+        prompt = f"""
+            Do a DNS analysis on the provided DNS scan information
+            The DNS output must return in a JSON format accorging to the provided
+            output format. The data must be accurate in regards towards a pentest report.
+            The data must follow the following rules:
+            1) The DNS scans must be done from a pentester point of view
+            2) The final output must be minimal according to the format given
+            3) The final output must be kept to a minimal
+
+            The output format:
+            {{
+                "A": [""],
+                "AAA": [""],
+                "NS": [""],
+                "MX": [""],
+                "PTR": [""],
+                "SOA": [""],
+                "TXT": [""]
+            }}
+            DNS Data to be analyzed: {data}
+            """
+
+        url = "https://generativelanguage.googleapis.com/v1beta2/models/text-bison-001:generateText?key=" + key
+
+        headers = {
+            "Content-Type": "application/json"
+        }
+
+        data = {
+            "prompt": {
+                "text": prompt
+            }
+        }
+
+        response = requests.post(url, json=data, headers=headers)
+
+        if response.status_code == 200:
+            generated_text = response.json()
+            data = dns_ai_data_regex(str(generated_text))
+            print(data)
+            return dns_ai_data_regex(str(generated_text))
+        else:
+            print("Error: Unable to generate text. Status Code:", response.status_code)
+            return "None"
+
+    @staticmethod
+    def llama_AI(self, data: str, mode: str, lkey, lendpoint):
+        api_url = 'http://localhost:5000/api/chatbot'
+
+        user_instruction = """
+            Do a DNS scan analysis on the provided DNS scan information. The DNS output must return in a asked format accorging to the provided output format. The data must be accurate in regards towards a pentest report.
+            The data must follow the following rules:
+            1) The DNS scans must be done from a pentester point of view
+            2) The final output must be minimal according to the format given
+            3) The final output must be kept to a minimal
+            4) So the analysis and provide your view according to the given format
+            5) Remember to provide views as a security engineer or an security analyst.
+            The output format:
+            "A":
+            - List the A records and security views on them
+            "AAA":
+            - List the AAA records and security views on them
+            "NS":
+            - List the NS records and security views on them
+            "MX":
+            - List the MX records and security views on them
+            "PTR":
+            - List the PTR records and security views on them
+            "SOA":
+            - List the SOA records and security views on them
+            "TXT":
+            - List the TXT records and security views on them
+        """
+        user_message = f"""
+            DNS Data to be analyzed: {data}
+        """
+
+        model_name = "TheBloke/Llama-2-7B-Chat-GGML"
+        file_name = "llama-2-7b-chat.ggmlv3.q4_K_M.bin"
+        if mode == "local":
+            bot_response = self.chat_with_api(api_url, user_message, user_instruction, model_name, file_name)
+        elif mode == "runpod":
+            prompt = f"[INST] <<SYS>> {user_instruction}<</SYS>> NMAP Data to be analyzed: {user_message} [/INST]"
+            bot_response = self.llama_runpod_api(prompt, lkey, lendpoint)
+        bot_response = self.chat_with_api(api_url, user_message, user_instruction, model_name, file_name)
+        print("test")
+        if bot_response:
+            return bot_response
+
+    @staticmethod
+    def gpt_ai(analyze: str, key: Optional[str]) -> str:
+        openai.api_key = key
+        prompt = f"""
+        Do a DNS analysis on the provided DNS scan information
+        The DNS output must return in a JSON format accorging to the provided
+        output format. The data must be accurate in regards towards a pentest report.
+        The data must follow the following rules:
+        1) The DNS scans must be done from a pentester point of view
+        2) The final output must be minimal according to the format given
+        3) The final output must be kept to a minimal
+
+        The output format:
+        {{
+            "A": [""],
+            "AAA": [""],
+            "NS": [""],
+            "MX": [""],
+            "PTR": [""],
+            "SOA": [""],
+            "TXT": [""]
+        }}
+
+        DNS Data to be analyzed: {analyze}
+        """
+        try:
+            # A structure for the request
+            messages = [{"content": prompt, "role": "user"}]
+            # A structure for the request
+            response = openai.ChatCompletion.create(
+                model=model_engine,
+                messages=messages,
+                max_tokens=1024,
+                n=1,
+                stop=None,
+            )
+            response = response['choices'][0]['message']['content']
+            return dns_ai_data_regex(str(response))
+        except KeyboardInterrupt:
+            print("Bye")
+            quit()
+
+
+class NMAP_AI_MODEL():
+    @staticmethod
+    def BardAI(key: str, data: Any) -> str:
+        prompt = f"""
+            Do a NMAP scan analysis on the provided NMAP scan information
+            The NMAP output must return in a JSON format accorging to the provided
+            output format. The data must be accurate in regards towards a pentest report.
+            The data must follow the following rules:
+            1) The NMAP scans must be done from a pentester point of view
+            2) The final output must be minimal according to the format given.
+            3) The final output must be kept to a minimal.
+            4) If a value not found in the scan just mention an empty string.
+            5) Analyze everything even the smallest of data.
+            6) Completely analyze the data provided and give a confirm answer using the output format.
+
+            The output format:
+            {{
+                "critical score": [""],
+                "os information": [""],
+                "open ports": [""],
+                "open services": [""],
+                "vulnerable service": [""],
+                "found cve": [""]
+            }}
+
+            NMAP Data to be analyzed: {data}
+            """
+
+        url = "https://generativelanguage.googleapis.com/v1beta2/models/text-bison-001:generateText?key=" + key
+
+        headers = {
+            "Content-Type": "application/json"
+        }
+
+        data = {
+            "prompt": {
+                "text": prompt
+            }
+        }
+
+        response = requests.post(url, json=data, headers=headers)
+
+        if response.status_code == 200:
+            generated_text = response.json()
+            return nmap_ai_data_regex(str(generated_text))
+        else:
+            print("Error: Unable to generate text. Status Code:", response.status_code)
+            return "None"
+
+    @staticmethod
+    def Llama_AI(data: str, mode: str, lkey: str, lendpoint: str) -> Any:
+        api_url = 'http://localhost:5000/api/chatbot'
+
+        user_instruction = """
+        Do a NMAP scan analysis on the provided NMAP scan information. The NMAP output must return in a asked format accorging to the provided output format. The data must be accurate in regards towards a pentest report.
+        The data must follow the following rules:
+        1) The NMAP scans must be done from a pentester point of view
+        2) The final output must be minimal according to the format given.
+        3) The final output must be kept to a minimal.
+        4) If a value not found in the scan just mention an empty string.
+        5) Analyze everything even the smallest of data.
+        6) Completely analyze the data provided and give a confirm answer using the output format.
+        7) mention all the data you found in the output format provided so that regex can be used on it.
+        8) avoid unnecessary explaination.
+        9) the critical score must be calculated based on the CVE if present or by the nature of the services open
+        10) the os information must contain the OS used my the target.
+        11) the open ports must include all the open ports listed in the data[tcp] and varifying if it by checking its states value.  you should not negect even one open port.
+        12) the vulnerable services can be determined via speculation of the service nature or by analyzing the CVE's found.
+        The output format:
+            critical score:
+            - Give info on the criticality
+            "os information":
+            - List out the OS information
+            "open ports and services":
+            - List open ports
+            - List open ports services
+            "vulnerable service":
+            - Based on CVEs or nature of the ports opened list the vulnerable services
+            "found cve":
+            - List the CVE's found and list the main issues.
+        """
+        user_message = f"""
+            NMAP Data to be analyzed: {data}
+        """
+        model_name = "TheBloke/Llama-2-7B-Chat-GGML"
+        file_name = "llama-2-7b-chat.ggmlv3.q4_K_M.bin"
+        if mode == "local":
+            bot_response = chat_with_api(api_url, user_message, user_instruction, model_name, file_name)
+        elif mode == "runpod":
+            prompt = f"[INST] <<SYS>> {user_instruction}<</SYS>> NMAP Data to be analyzed: {user_message} [/INST]"
+            bot_response = llama_runpod_api(prompt, lkey, lendpoint)
+        if bot_response:
+            return bot_response
+
+    @staticmethod
+    def GPT_AI(key: str, data: Any) -> str:
+        openai.api_key = key
+        try:
+            prompt = f"""
+            Do a NMAP scan analysis on the provided NMAP scan information
+            The NMAP output must return in a JSON format accorging to the provided
+            output format. The data must be accurate in regards towards a pentest report.
+            The data must follow the following rules:
+            1) The NMAP scans must be done from a pentester point of view
+            2) The final output must be minimal according to the format given.
+            3) The final output must be kept to a minimal.
+            4) If a value not found in the scan just mention an empty string.
+            5) Analyze everything even the smallest of data.
+            6) Completely analyze the data provided and give a confirm answer using the output format.
+
+            The output format:
+            {{
+                "critical score": [""],
+                "os information": [""],
+                "open ports": [""],
+                "open services": [""],
+                "vulnerable service": [""],
+                "found cve": [""]
+            }}
+
+            NMAP Data to be analyzed: {data}
+            """
+            # A structure for the request
+            messages = [{"content": prompt, "role": "assistant"}]
+            # A structure for the request
+            response = openai.ChatCompletion.create(
+                model=model_engine,
+                messages=messages,
+                max_tokens=2500,
+                n=1,
+                stop=None,
+            )
+            response = response['choices'][0]['message']['content']
+            rsp = str(response)
+            return str(nmap_ai_data_regex(rsp))
+        except KeyboardInterrupt:
+            print("Bye")
+            quit()
+
+
+class JWT_AI_MODEL():
+    @staticmethod
+    def BardAI(key: str, jwt_data: Any) -> str:
+        prompt = f"""
+        Perform a comprehensive analysis on the provided JWT token. The analysis output must be in a JSON format according to the provided output structure. Ensure accuracy for inclusion in a penetration testing report.
+        Follow these guidelines:
+        1) Analyze the JWT token from a pentester's perspective
+        2) Keep the final output minimal while adhering to the given format
+        3) Highlight JWT-specific details and enumerate possible attacks and vulnerabilities
+        5) For the output "Algorithm Used" value use the Algorithm value from the JWT data.
+        6) For the output "Header" value use the Header value from the JWT data.
+        7) For the "Payload" Use the decoded payloads as a reference and then analyze any attack endpoints.
+        8) For "Signature" mention the signatures discovered.
+        9) List a few endpoints you feel are vulnerable for "VulnerableEndpoints"
+
+        The output format:
+        {{
+            "Algorithm Used": "",
+            "Header": "",
+            "Payload": "",
+            "Signature": "",
+            "PossibleAttacks": "",
+            "VulnerableEndpoints": ""
+        }}
+
+        JWT Token Data to be analyzed: {jwt_data}
+        """
+
+        url = "https://generativelanguage.googleapis.com/v1beta2/models/text-bison-001:generateText?key=" + key
+
+        headers = {
+            "Content-Type": "application/json"
+        }
+
+        data = {
+            "prompt": {
+                "text": prompt
+            }
+        }
+
+        response = requests.post(url, json=data, headers=headers)
+
+        if response.status_code == 200:
+            generated_text = response.json()
+            jwt_analysis_data = jwt_ai_data_regex(str(generated_text))
+            print(jwt_analysis_data)
+            return jwt_analysis_data
+        else:
+            print("Error: Unable to generate text. Status Code:", response.status_code)
+            return "None"
+
+    @staticmethod
+    def llama_AI(self, jwt_data: str, mode: str, lkey, lendpoint):
+        api_url = 'http://localhost:5000/api/chatbot'
+
+        user_instruction = """
+            Perform a comprehensive analysis on the provided JWT token. The JWT analysis output must be in a asked format according to the provided output structure. Ensure accuracy for inclusion in a penetration testing report.
+            Follow these guidelines:
+            1) Analyze the JWT token from a pentester's perspective
+            2) Keep the final output minimal while adhering to the given format
+            3) Highlight JWT-specific details and enumerate possible attacks
+
+            The output format:
+            "Header":
+            - List the JWT header details and security views on them
+            "Payload":
+            - List the JWT payload details and security views on them
+            "Signature":
+            - Provide insights on the JWT signature
+            "PossibleAttacks":
+            - List possible JWT exploits and attacks
+        """
+        user_message = f"""
+            JWT Token Data to be analyzed: {jwt_data}
+        """
+
+        model_name = "TheBloke/Llama-2-7B-Chat-GGML"
+        file_name = "llama-2-7b-chat.ggmlv3.q4_K_M.bin"
+        if mode == "local":
+            bot_response = self.chat_with_api(api_url, user_message, user_instruction, model_name, file_name)
+        elif mode == "runpod":
+            prompt = f"[INST] <<SYS>> {user_instruction}<</SYS>> JWT Token Data to be analyzed: {user_message} [/INST]"
+            bot_response = self.llama_runpod_api(prompt, lkey, lendpoint)
+        bot_response = self.chat_with_api(api_url, user_message, user_instruction, model_name, file_name)
+        print("test")
+        if bot_response:
+            return bot_response
+
+    @staticmethod
+    def gpt_ai(analyze: str, api_key: Optional[str]) -> str:
+        openai.api_key = api_key
+        prompt = f"""
+        Perform a comprehensive analysis on the provided JWT token. The analysis output must be in a JSON format according to the provided output structure. Ensure accuracy for inclusion in a penetration testing report.
+        Follow these guidelines:
+        1) Analyze the JWT token from a pentester's perspective
+        2) Keep the final output minimal while adhering to the given format
+        3) Highlight JWT-specific details and enumerate possible attacks and vulnerabilities
+        5) For the output "Algorithm Used" value use the Algorithm value from the JWT data.
+        6) For the output "Header" value use the Header value from the JWT data.
+        7) For the "Payload" Use the decoded payloads as a reference and then analyze any attack endpoints.
+        8) For "Signature" mention the signatures discovered.
+        9) List a few endpoints you feel are vulnerable for "VulnerableEndpoints"
+
+        The output format:
+        {{
+            "Algorithm Used": "",
+            "Header": "",
+            "Payload": "",
+            "Signature": "",
+            "PossibleAttacks": "",
+            "VulnerableEndpoints": ""
+        }}
+
+        JWT Token Data to be analyzed: {analyze}
+        """
+        try:
+            messages = [{"content": prompt, "role": "user"}]
+            response = openai.ChatCompletion.create(
+                model=model_engine,
+                messages=messages,
+                max_tokens=1024,
+                n=1,
+                stop=None,
+            )
+            response = response['choices'][0]['message']['content']
+            rsp = str(response)
+            return rsp
+        except KeyboardInterrupt:
+            print("Bye")
+            quit()
+
+
+def chat_with_api(api_url: str, user_message: str, user_instruction: str, model_name: str, file_name: str = None) -> Any:
+    # Prepare the request data in JSON format
+    data = {
+        'user_message': user_message,
+        'model_name': model_name,
+        'file_name': file_name,
+        'user_instruction': user_instruction
+    }
+
+    # Send the POST request to the API
+    response = requests.post(api_url, json=data)
+
+    # Check if the request was successful (status code 200)
+    if response.status_code == 200:
+        return response.json()['bot_response']
+    else:
+        # If there was an error, print the error message
+        print(f"Error: {response.status_code} - {response.text}")
+        return None
+
+
+def llama_runpod_api(prompt: str, lkey: str, lendpoint: str) -> Any:
+    url = f"https://api.runpod.ai/v2/{lendpoint}/runsync"
+    payload = json.dumps({
+        "input": {
+            "prompt": prompt,
+            "max_new_tokens": 4500,
+            "temperature": 0.9,
+            "top_k": 50,
+            "top_p": 0.7,
+            "repetition_penalty": 1.2,
+            "batch_size": 8,
+            "stop": [
+                "</s>"
+            ]
+        }
+    })
+    headers = {
+        'Content-Type': 'application/json',
+        'Authorization': f'Bearer {lkey}',
+    }
+    response = requests.request("POST", url, headers=headers, data=payload)
+    response_t = json.loads(response.text)
+    return response_t["output"]
+
+
+def dns_ai_data_regex(json_string: str) -> Any:
+    # Define the regular expression patterns for individual values
+    A_pattern = r'"A": \["(.*?)"\]'
+    AAA_pattern = r'"AAA: \["(.*?)"\]'
+    NS_pattern = r'"NS": \["(.*?)"\]'
+    MX_pattern = r'"MX": \["(.*?)"\]'
+    PTR_pattern = r'"PTR": \["(.*?)"\]'
+    SOA_pattern = r'"SOA": \["(.*?)"\]'
+    TXT_pattern = r'"TXT": \["(.*?)"\]'
+
+    # Initialize variables for extracted data
+    A = None
+    AAA = None
+    NS = None
+    MX = None
+    PTR = None
+    SOA = None
+    TXT = None
+
+    # Extract individual values using patterns
+    match = re.search(A_pattern, json_string)
+    if match:
+        A = match.group(1)
+        match = re.search(AAA_pattern, json_string)
+    if match:
+        AAA = match.group(1)
+        match = re.search(NS_pattern, json_string)
+    if match:
+        NS = match.group(1)
+        match = re.search(MX_pattern, json_string)
+    if match:
+        MX = match.group(1)
+        match = re.search(PTR_pattern, json_string)
+    if match:
+        PTR = match.group(1)
+        match = re.search(SOA_pattern, json_string)
+    if match:
+        SOA = match.group(1)
+        match = re.search(TXT_pattern, json_string)
+    if match:
+        TXT = match.group(1)
+
+        # Create a dictionary to store the extracted data
+    data = {
+        "A": A,
+        "AAA": AAA,
+        "NS": NS,
+        "MX": MX,
+        "PTR": PTR,
+        "SOA": SOA,
+        "TXT": TXT
+    }
+
+    # Convert the dictionary to JSON format
+    json_output = json.dumps(data)
+
+    return json_output
+
+
+def nmap_ai_data_regex(json_string: str) -> Any:
+    # Define the regular expression patterns for individual values
+    critical_score_pattern = r'"critical score": \["(.*?)"\]'
+    os_information_pattern = r'"os information": \["(.*?)"\]'
+    open_ports_pattern = r'"open ports": \["(.*?)"\]'
+    open_services_pattern = r'"open services": \["(.*?)"\]'
+    vulnerable_service_pattern = r'"vulnerable service": \["(.*?)"\]'
+    found_cve_pattern = r'"found cve": \["(.*?)"\]'
+    # Initialize variables for extracted data
+    critical_score = None
+    os_information = None
+    open_ports = None
+    open_services = None
+    vulnerable_service = None
+    found_cve = None
+
+    # Extract individual values using patterns
+    match = re.search(critical_score_pattern, json_string)
+    if match:
+        critical_score = match.group(1)
+
+    match = re.search(os_information_pattern, json_string)
+    if match:
+        os_information = match.group(1)
+    match = re.search(open_ports_pattern, json_string)
+    if match:
+        open_ports = match.group(1)
+    match = re.search(open_services_pattern, json_string)
+    if match:
+        open_services = match.group(1)
+
+    match = re.search(vulnerable_service_pattern, json_string)
+    if match:
+        vulnerable_service = match.group(1)
+
+    match = re.search(found_cve_pattern, json_string)
+    if match:
+        found_cve = match.group(1)
+
+    # Create a dictionary to store the extracted data
+    data = {
+        "critical score": critical_score,
+        "os information": os_information,
+        "open ports": open_ports,
+        "open services": open_services,
+        "vulnerable service": vulnerable_service,
+        "found cve": found_cve
+    }
+
+    # Convert the dictionary to JSON format
+    json_output = json.dumps(data)
+
+    return json_output
+
+
+def jwt_ai_data_regex(json_string: str) -> Any:
+    # Define the regular expression patterns for individual values
+    header_pattern = r'"Header": \{\s*"alg": "(.*?)",\s*"typ": "(.*?)"\s*\}'
+    payload_pattern = r'"Payload": \{\s*"iss": "(.*?)",\s*"sub": "(.*?)",\s*"aud": "(.*?)",\s*"exp": "(.*?)",\s*"nbf": "(.*?)",\s*"iat": "(.*?)"\s*\}'
+    signature_pattern = r'"Signature": "(.*?)"'
+    possible_attacks_pattern = r'"PossibleAttacks": "(.*?)"'
+    vulnerable_endpoints_pattern = r'"VulnerableEndpoints": "(.*?)"'
+
+    # Initialize variables for extracted data
+    header = {}
+    payload = {}
+    signature = ""
+    possible_attacks = ""
+    vulnerable_endpoints = ""
+
+    # Extract individual values using patterns
+    match_header = re.search(header_pattern, json_string)
+    if match_header:
+        header = {"alg": match_header.group(1), "typ": match_header.group(2)}
+
+    match_payload = re.search(payload_pattern, json_string)
+    if match_payload:
+        payload = {
+            "iss": match_payload.group(1),
+            "sub": match_payload.group(2),
+            "aud": match_payload.group(3),
+            "exp": match_payload.group(4),
+            "nbf": match_payload.group(5),
+            "iat": match_payload.group(6)
+        }
+
+    match_signature = re.search(signature_pattern, json_string)
+    if match_signature:
+        signature = match_signature.group(1)
+
+    match_attacks = re.search(possible_attacks_pattern, json_string)
+    if match_attacks:
+        possible_attacks = match_attacks.group(1)
+
+    match_endpoints = re.search(vulnerable_endpoints_pattern, json_string)
+    if match_endpoints:
+        vulnerable_endpoints = match_endpoints.group(1)
+
+    # Create a dictionary to store the extracted data
+    data = {
+        "Header": header,
+        "Payload": payload,
+        "Signature": signature,
+        "PossibleAttacks": possible_attacks,
+        "VulnerableEndpoints": vulnerable_endpoints
+    }
+
+    # Convert the dictionary to JSON format
+    json_output = json.dumps(data)
+
+    return json_output

components/assets.py

@@ -0,0 +1,184 @@
+import json
+import os
+import platform
+import subprocess
+from typing import Any
+from rich import print
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.console import Group
+from rich.align import Align
+from rich import box
+from rich.markdown import Markdown
+
+console = Console()
+
+
+class Assets():
+    def clearscr() -> None:
+        try:
+            osp = platform.system()
+            match osp:
+                case 'Darwin':
+                    os.system("clear")
+                case 'Linux':
+                    os.system("clear")
+                case 'Windows':
+                    os.system("cls")
+        except Exception:
+            pass
+
+    def start_api_app():
+        CREATE_NEW_CONSOLE = 0x00000010
+        osp = platform.system()
+        match osp:
+            case 'Darwin':
+                subprocess.Popen(["python3", "llama_api.py"], creationflags=CREATE_NEW_CONSOLE)
+            case 'Linux':
+                subprocess.Popen(["python3", "llama_api.py"])
+            case 'Windows':
+                subprocess.Popen(["python", "llama_api.py"], creationflags=CREATE_NEW_CONSOLE)
+
+    def flatten_json(self, data: Any, separator: Any = '.') -> Any:
+        flattened_data = {}
+        for key, value in data.items():
+            if isinstance(value, dict):
+                nested_data = self.flatten_json(value, separator)
+                for nested_key, nested_value in nested_data.items():
+                    flattened_data[key + separator + nested_key] = nested_value
+            else:
+                flattened_data[key] = value
+        return flattened_data
+
+    def help_menu() -> None:
+        table = Table(title="Help Menu for GVA")
+        table.add_column("Options", style="cyan")
+        table.add_column("Input Type", style="green")
+        table.add_column("Argument Input", style="green")
+        table.add_column("Discription", style="green")
+        table.add_column("Other internal options", style="green")
+        table.add_row("Attack", "--attack", "TXT/STRING",
+                      "The Attack the user whats to run", "sub / dns / nmap / geo")
+        table.add_row("Target", "--target", "IP/HOSTNAME",
+                      "The target of the user", "None")
+        table.add_row("Domain List", "--list", "Path to text file",
+                      "subdomain dictionary list", "Path")
+        table.add_row("Profile", "--profile", "INT (1-5)",
+                      "The type of Nmap Scan the user intends", "None")
+        table.add_row("AI", "--ai", "STRING",
+                      "Choose your AI of choice", "bard / openai (default)")
+        table.add_row("menu", "--menu", "BOOL",
+                      "Interactive UI menu", "True / False (Default)")
+        table.add_row("Rich Help", "--r", "STRING",
+                      "Pritty Help menu", "help")
+        console.print(table)
+
+    def print_output(self, attack_type: str, jdata: str, ai: str) -> Any:
+        match attack_type:
+            case "Nmap":
+                match ai:
+                    case 'openai':
+                        data = json.loads(jdata)
+                        table = Table(title=f"GVA Report for {attack_type}", show_header=True, header_style="bold magenta")
+                        table.add_column("Variables", style="cyan")
+                        table.add_column("Results", style="green")
+
+                        for key, value in data.items():
+                            table.add_row(key, value)
+                        print(table)
+                    case 'bard':
+                        data = json.loads(jdata)
+                        table = Table(title=f"GVA Report for {attack_type}", show_header=True, header_style="bold magenta")
+                        table.add_column("Variables", style="cyan")
+                        table.add_column("Results", style="green")
+
+                        for key, value in data.items():
+                            table.add_row(key, value)
+                        print(table)
+                    case 'llama':
+                        ai_out = Markdown(jdata)
+                        message_panel = Panel(
+                            Align.center(
+                                Group("\n", Align.center(ai_out)),
+                                vertical="middle",
+                            ),
+                            box=box.ROUNDED,
+                            padding=(1, 2),
+                            title="[b red]The GVA LLama2",
+                            border_style="blue",
+                        )
+                        print(message_panel)
+                    case 'llama-api':
+                        ai_out = Markdown(jdata)
+                        message_panel = Panel(
+                            Align.center(
+                                Group("\n", Align.center(ai_out)),
+                                vertical="middle",
+                            ),
+                            box=box.ROUNDED,
+                            padding=(1, 2),
+                            title="[b red]The GVA LLama2",
+                            border_style="blue",
+                        )
+                        print(message_panel)
+            case "DNS":
+                match ai:
+                    case 'openai':
+                        data = json.loads(jdata)
+                        table = Table(title=f"GVA Report for {attack_type}", show_header=True, header_style="bold magenta")
+                        table.add_column("Variables", style="cyan")
+                        table.add_column("Results", style="green")
+
+                        for key, value in data.items():
+                            table.add_row(key, value)
+                        print(table)
+                    case 'bard':
+                        data = json.loads(jdata)
+                        table = Table(title=f"GVA Report for {attack_type}", show_header=True, header_style="bold magenta")
+                        table.add_column("Variables", style="cyan")
+                        table.add_column("Results", style="green")
+
+                        for key, value in data.items():
+                            table.add_row(key, value)
+                        print(table)
+                    case 'llama':
+                        ai_out = Markdown(jdata)
+                        message_panel = Panel(
+                            Align.center(
+                                Group("\n", Align.center(ai_out)),
+                                vertical="middle",
+                            ),
+                            box=box.ROUNDED,
+                            padding=(1, 2),
+                            title="[b red]The GVA LLama2",
+                            border_style="blue",
+                        )
+                        print(message_panel)
+                    case 'llama-api':
+                        ai_out = Markdown(jdata)
+                        message_panel = Panel(
+                            Align.center(
+                                Group("\n", Align.center(ai_out)),
+                                vertical="middle",
+                            ),
+                            box=box.ROUNDED,
+                            padding=(1, 2),
+                            title="[b red]The GVA LLama2",
+                            border_style="blue",
+                        )
+                        print(message_panel)
+            case "GeoIP":
+                data = json.loads(jdata)
+                table = Table(title="GVA Report for GeoIP", show_header=True, header_style="bold magenta")
+                table.add_column("Identifiers", style="cyan")
+                table.add_column("Data", style="green")
+
+                flattened_data: dict = self.flatten_json(data, separator='.')
+
+                for key, value in flattened_data.items():
+                    value_str = str(value)
+                    table.add_row(key, value_str)
+
+                console = Console()
+                console.print(table)

components/dns_recon.py

@@ -0,0 +1,51 @@
+from typing import Any, Optional
+import requests
+import dns.resolver as dns_resolver_module
+from rich.progress import track
+
+
+class DNSRecon:
+    def dns_resolver(self, AIModels, target: str, akey: Optional[str], bkey: Optional[str], lkey, lendpoint, AI: str) -> Any:
+        if target is None:
+            raise ValueError("InvalidTarget: Target Not Provided")
+
+        analyze = ''
+        record_types = ['A', 'AAAA', 'NS', 'CNAME', 'MX', 'PTR', 'SOA', 'TXT']
+        for record_type in track(record_types):
+            try:
+                answer = dns_resolver_module.resolve(target, record_type)
+                for server in answer:
+                    st = server.to_text()
+                    analyze += f"\n{record_type} : {st}"
+            except dns_resolver_module.NoAnswer:
+                print('No record Found')
+            except dns_resolver_module.NXDOMAIN:
+                print('NXDOMAIN record NOT Found')
+            except dns_resolver_module.LifetimeTimeout:
+                print("Timed out, check your internet")
+            except requests.exceptions.InvalidHeader:
+                pass
+            except KeyboardInterrupt:
+                print("Bye")
+                quit()
+
+        response = ""
+        match AI:
+            case 'openai':
+                if akey is None:
+                    raise ValueError("KeyNotFound: Key Not Provided")
+                akey = akey.replace('\n', '')
+                response = AIModels.gpt_ai(akey, analyze)
+            case 'bard':
+                if bkey is None:
+                    raise ValueError("KeyNotFound: Key Not Provided")
+                bkey = bkey.replace('\n', '')
+                response = AIModels.BardAI(bkey, analyze)
+            case 'llama':
+                response = AIModels.llama_AI(analyze, "local", lkey, lendpoint)
+            case 'llama-api':
+                response = AIModels.llama_AI(analyze, "runpod", lkey, lendpoint)
+            except KeyboardInterrupt:
+                print("Bye")
+                quit()
+        return str(response)

components/geo.py

@@ -0,0 +1,13 @@
+from typing import Any, Optional
+import requests
+
+class GeoIPRecon:
+    def geoip(key: Optional[str], target: str) -> Any:
+        if key is None:
+            raise ValueError("KeyNotFound: Key Not Provided")
+        if target is None:
+            raise ValueError("InvalidTarget: Target Not Provided")
+
+        url = f"https://api.ipgeolocation.io/ipgeo?apiKey={key}&ip={target}"
+        response = requests.get(url)
+        return response.text

components/gui.py

@@ -0,0 +1,425 @@
+import json
+import re
+from typing import Any
+from typing import Optional
+
+import customtkinter
+import dns.resolver
+import nmap
+import openai
+import requests
+from rich.progress import track
+
+customtkinter.set_appearance_mode("dark")
+customtkinter.set_default_color_theme("dark-blue")
+
+root = customtkinter.CTk()
+root.title("GVA - GUI")
+root.geometry("600x400")
+
+nm = nmap.PortScanner()
+model_engine = "text-davinci-003"
+
+
+def application() -> None:
+    try:
+        apikey = entry1.get()
+        openai.api_key = apikey
+        target = entry2.get()
+        attack = entry5.get()
+        outputf = str(entry4.get())
+        match attack:
+            case 'geo':
+                val = geoip(apikey, target)
+                print(val)
+                output_save(val, outputf)
+            case "nmap":
+                p = int(entry3.get())
+                match p:
+                    case 1:
+                        val = scanner(target, 1, apikey)
+                        print(val)
+                        output_save(val, outputf)
+                    case 2:
+                        val = scanner(target, 2, apikey)
+                        print(val)
+                        output_save(val, outputf)
+                    case 3:
+                        val = scanner(target, 3, apikey)
+                        print(val)
+                        output_save(val, outputf)
+                    case 4:
+                        val = scanner(target, 4, apikey)
+                        print(val)
+                        output_save(val, outputf)
+                    case 5:
+                        val = scanner(target, 5, apikey)
+                        print(val)
+                        output_save(val, outputf)
+            case "dns":
+                val = dns_recon(target, apikey)
+                output_save(val, outputf)
+            case "subd":
+                val = sub(target)
+                output_save(val, outputf)
+    except KeyboardInterrupt:
+        print("Keyboard Interrupt detected ...")
+
+
+def dns_extract_data(json_string: str) -> Any:
+    # Define the regular expression patterns for individual values
+    A_pattern = r'"A": \["(.*?)"\]'
+    AAA_pattern = r'"AAA: \["(.*?)"\]'
+    NS_pattern = r'"NS": \["(.*?)"\]'
+    MX_pattern = r'"MX": \["(.*?)"\]'
+    PTR_pattern = r'"PTR": \["(.*?)"\]'
+    SOA_pattern = r'"SOA": \["(.*?)"\]'
+    TXT_pattern = r'"TXT": \["(.*?)"\]'
+
+    # Initialize variables for extracted data
+    A = None
+    AAA = None
+    NS = None
+    MX = None
+    PTR = None
+    SOA = None
+    TXT = None
+
+    # Extract individual values using patterns
+    match = re.search(A_pattern, json_string)
+    if match:
+        A = match.group(1)
+
+    match = re.search(AAA_pattern, json_string)
+    if match:
+        AAA = match.group(1)
+
+    match = re.search(NS_pattern, json_string)
+    if match:
+        NS = match.group(1)
+
+    match = re.search(MX_pattern, json_string)
+    if match:
+        MX = match.group(1)
+
+    match = re.search(PTR_pattern, json_string)
+    if match:
+        PTR = match.group(1)
+
+    match = re.search(SOA_pattern, json_string)
+    if match:
+        SOA = match.group(1)
+
+    match = re.search(TXT_pattern, json_string)
+    if match:
+        TXT = match.group(1)
+
+    # Create a dictionary to store the extracted data
+    data = {
+        "A": A,
+        "AAA": AAA,
+        "NS": NS,
+        "MX": MX,
+        "PTR": PTR,
+        "SOA": SOA,
+        "TXT": TXT
+    }
+
+    # Convert the dictionary to JSON format
+    json_output = json.dumps(data)
+
+    return json_output
+
+
+def port_extract_data(json_string: str) -> Any:
+    # Define the regular expression patterns for individual values
+    critical_score_pattern = r'"critical score": \["(.*?)"\]'
+    os_information_pattern = r'"os information": \["(.*?)"\]'
+    open_ports_pattern = r'"open ports": \["(.*?)"\]'
+    open_services_pattern = r'"open services": \["(.*?)"\]'
+    vulnerable_service_pattern = r'"vulnerable service": \["(.*?)"\]'
+    found_cve_pattern = r'"found cve": \["(.*?)"\]'
+
+    # Initialize variables for extracted data
+    critical_score = None
+    os_information = None
+    open_ports = None
+    open_services = None
+    vulnerable_service = None
+    found_cve = None
+
+    # Extract individual values using patterns
+    match = re.search(critical_score_pattern, json_string)
+    if match:
+        critical_score = match.group(1)
+
+    match = re.search(os_information_pattern, json_string)
+    if match:
+        os_information = match.group(1)
+
+    match = re.search(open_ports_pattern, json_string)
+    if match:
+        open_ports = match.group(1)
+
+    match = re.search(open_services_pattern, json_string)
+    if match:
+        open_services = match.group(1)
+
+    match = re.search(vulnerable_service_pattern, json_string)
+    if match:
+        vulnerable_service = match.group(1)
+
+    match = re.search(found_cve_pattern, json_string)
+    if match:
+        found_cve = match.group(1)
+
+    # Create a dictionary to store the extracted data
+    data = {
+        "critical score": critical_score,
+        "os information": os_information,
+        "open ports": open_ports,
+        "open services": open_services,
+        "vulnerable service": vulnerable_service,
+        "found cve": found_cve
+    }
+
+    # Convert the dictionary to JSON format
+    json_output = json.dumps(data)
+
+    return json_output
+
+
+def DnsAI(analyze: str, key: Optional[str]) -> str:
+    openai.api_key = key
+    prompt = f"""
+    Do a DNS analysis on the provided DNS scan information
+    The DNS output must return in a JSON format accorging to the provided
+    output format. The data must be accurate in regards towards a pentest report.
+    The data must follow the following rules:
+    1) The DNS scans must be done from a pentester point of view
+    2) The final output must be minimal according to the format given
+    3) The final output must be kept to a minimal
+
+    The output format:
+    {{
+        "A": [""],
+        "AAA": [""],
+        "NS": [""],
+        "MX": [""],
+        "PTR": [""],
+        "SOA": [""],
+        "TXT": [""]
+    }}
+
+    DNS Data to be analyzed: {analyze}
+    """
+    try:
+        # A structure for the request
+        completion = openai.Completion.create(
+            engine=model_engine,
+            prompt=prompt,
+            max_tokens=1024,
+            n=1,
+            stop=None,
+        )
+        response = completion.choices[0].text
+        return dns_extract_data(str(response))
+    except KeyboardInterrupt:
+        print("Bye")
+        quit()
+
+
+def PortAI(key: str, data: Any) -> str:
+    openai.api_key = key
+    try:
+        prompt = f"""
+        Do a NMAP scan analysis on the provided NMAP scan information
+        The NMAP output must return in a JSON format accorging to the provided
+        output format. The data must be accurate in regards towards a pentest report.
+        The data must follow the following rules:
+        1) The NMAP scans must be done from a pentester point of view
+        2) The final output must be minimal according to the format given.
+        3) The final output must be kept to a minimal.
+        4) If a value not found in the scan just mention an empty string.
+        5) Analyze everything even the smallest of data.
+
+        The output format:
+        {{
+            "critical score": [""],
+            "os information": [""],
+            "open ports": [""],
+            "open services": [""],
+            "vulnerable service": [""],
+            "found cve": [""]
+        }}
+
+        NMAP Data to be analyzed: {data}
+        """
+        # A structure for the request
+        completion = openai.Completion.create(
+            engine=model_engine,
+            prompt=prompt,
+            max_tokens=1024,
+            n=1,
+            stop=None,
+        )
+        response = completion.choices[0].text
+        return port_extract_data(str(response))
+    except KeyboardInterrupt:
+        print("Bye")
+        quit()
+
+
+def geoip(key: Optional[str], target: str) -> Any:
+    if key is None:
+        raise ValueError("KeyNotFound: Key Not Provided")
+    assert key is not None  # This will help the type checker
+    if target is None:
+        raise ValueError("InvalidTarget: Target Not Provided")
+    url = f"https://api.ipgeolocation.io/ipgeo?apiKey={key}&ip={target}"
+    response = requests.get(url)
+    content = response.text
+    return content
+
+
+def output_save(output: Any, outf: Any) -> Any:
+    top = customtkinter.CTkToplevel(root)
+    top.title("GVA Output")
+    top.grid_rowconfigure(0, weight=1)
+    top.grid_columnconfigure(0, weight=1)
+    top.textbox = customtkinter.CTkTextbox(
+        master=top, height=500, width=400, corner_radius=0)
+    top.textbox.grid(row=0, column=0, sticky="nsew")
+
+    try:
+        file = open(outf, 'x')
+    except FileExistsError:
+        file = open(outf, "r+")
+    file.write(str(output))
+    file.close
+    top.textbox.insert("0.0", text=output)
+
+
+def sub(target: str) -> Any:
+    s_array = ['www', 'mail', 'ftp', 'localhost', 'webmail', 'smtp', 'hod', 'butterfly', 'ckp',
+               'tele2', 'receiver', 'reality', 'panopto', 't7', 'thot', 'wien', 'uat-online', 'Footer']
+
+    ss = []
+    out = ""
+    for subd in s_array:
+        try:
+            ip_value = dns.resolver.resolve(f'{subd}.{target}', 'A')
+            if ip_value:
+                ss.append(f'{subd}.{target}')
+                if f"{subd}.{target}" in ss:
+                    print(f'{subd}.{target} | Found')
+                    out += f'{subd}.{target}'
+                    out += "\n"
+                    out += ""
+                else:
+                    pass
+        except dns.resolver.NXDOMAIN:
+            pass
+        except dns.resolver.NoAnswer:
+            pass
+        except KeyboardInterrupt:
+            print('Ended')
+            quit()
+    return out
+
+
+def dns_recon(target: Optional[str], key: str) -> str:
+    if key is not None:
+        pass
+    else:
+        raise ValueError("KeyNotFound: Key Not Provided")
+    if target is not None:
+        pass
+    else:
+        raise ValueError("InvalidTarget: Target Not Provided")
+    analyze = ''
+    # The DNS Records to be enumeratee
+    record_types = ['A', 'AAAA', 'NS', 'CNAME', 'MX', 'PTR', 'SOA', 'TXT']
+    for records in track(record_types):
+        try:
+            answer = dns.resolver.resolve(target, records)
+            for server in answer:
+                st = server.to_text()
+                analyze += "\n"
+                analyze += records
+                analyze += " : "
+                analyze += st
+        except dns.resolver.NoAnswer:
+            print('No record Found')
+            pass
+        except dns.resolver.NXDOMAIN:
+            print('NXDOMAIN record NOT Found')
+            pass
+        except KeyboardInterrupt:
+            print("Bye")
+            quit()
+    try:
+        response = DnsAI(key, analyze)
+        return str(response)
+    except KeyboardInterrupt:
+        print("Bye")
+        quit()
+
+
+def scanner(ip: Optional[str], profile: int, key: str) -> str:
+    if key is not None:
+        pass
+    else:
+        raise ValueError("KeyNotFound: Key Not Provided")
+    # Handle the None case
+    profile_argument = ""
+    # The port profiles or scan types user can choose
+    if profile == 1:
+        profile_argument = '-Pn -sV -T4 -O -F'
+    elif profile == 2:
+        profile_argument = '-Pn -T4 -A -v'
+    elif profile == 3:
+        profile_argument = '-Pn -sS -sU -T4 -A -v'
+    elif profile == 4:
+        profile_argument = '-Pn -p- -T4 -A -v'
+    elif profile == 5:
+        profile_argument = '-Pn -sS -sU -T4 -A -PE -PP -PS80,443 -PA3389 -PU40125 -PY -g 53 --script=vuln'
+    else:
+        raise ValueError(f"Invalid Argument: {profile}")
+    # The scanner with GPT Implemented
+    nm.scan('{}'.format(ip), arguments='{}'.format(profile_argument))
+    json_data = nm.analyse_nmap_xml_scan()
+    analyze = json_data["scan"]
+    try:
+        response = PortAI(key, analyze)
+    except KeyboardInterrupt:
+        print("Bye")
+        quit()
+    return str(response)
+
+
+frame = customtkinter.CTkFrame(master=root)
+frame.pack(pady=20, padx=60, fill="both", expand=True)
+
+label = customtkinter.CTkLabel(
+    master=frame, text="GVA System")
+label.pack(pady=12, padx=10)
+
+entry1 = customtkinter.CTkEntry(master=frame, placeholder_text="API_KEY")
+entry1.pack(pady=12, padx=10)
+entry2 = customtkinter.CTkEntry(master=frame, placeholder_text="Target")
+entry2.pack(pady=12, padx=10)
+entry5 = customtkinter.CTkEntry(
+    master=frame, placeholder_text="Attack (nmap/dns)")
+entry5.pack(pady=12, padx=10)
+entry4 = customtkinter.CTkEntry(master=frame, placeholder_text="Savefile.json")
+entry4.pack(pady=12, padx=10)
+entry3 = customtkinter.CTkEntry(
+    master=frame, placeholder_text="Profile (Only Nmap)")
+entry3.pack(pady=12, padx=10)
+radiobutton_var = customtkinter.IntVar(value=1)
+button = customtkinter.CTkButton(
+    master=frame, text="Run", command=application)
+button.pack(pady=12, padx=10)
+
+root.mainloop()

components/jwt.py

@@ -0,0 +1,42 @@
+import json
+import base64
+from datetime import datetime
+from typing import Optional
+
+class JWTAnalyzer:
+    def analyze(self, AIModels, token, openai_api_token: Optional[str], bard_api_token: Optional[str], llama_api_token: Optional[str], llama_endpoint: Optional[str], AI: str):
+        try:
+            parts = token.split('.')
+            if len(parts) != 3:
+                raise ValueError("Invalid token format. Expected 3 parts.")
+            header = json.loads(base64.urlsafe_b64decode(parts[0] + '===').decode('utf-8', 'replace'))
+            payload = json.loads(base64.urlsafe_b64decode(parts[1] + '===').decode('utf-8', 'replace'))
+            algorithm_used = header.get('alg', 'Unknown Algorithm')
+            expiration_time = datetime.utcfromtimestamp(payload['exp']) if 'exp' in payload else None
+
+            analysis_result = {
+                'Algorithm Used': algorithm_used,
+                'Decoded Payload': payload,
+                'Claims': json.dumps(payload, indent=4),
+                'Expires At': expiration_time.strftime('%Y-%m-%d %H:%M:%S') if expiration_time else 'Not Expired'
+            }
+            
+            response = ""
+            match AI:
+                case 'openai':
+                    if openai_api_token is None:
+                        raise ValueError("KeyNotFound: Key Not Provided")
+                    response = AIModels.gpt_ai(openai_api_token, json.dumps(analysis_result))
+                case 'bard':
+                    if bard_api_token is None:
+                        raise ValueError("KeyNotFound: Key Not Provided")
+                    response = AIModels.BardAI(bard_api_token, json.dumps(analysis_result))
+                case 'llama':
+                    response = AIModels.llama_AI(json.dumps(analysis_result), "local", llama_api_token, llama_endpoint)
+                case 'llama-api':
+                    response = AIModels.llama_AI(json.dumps(analysis_result), "runpod", llama_api_token, llama_endpoint)
+        except jwt.ExpiredSignatureError:
+            analysis_result = {'Error': 'Token has expired.'}
+        except jwt.InvalidTokenError as e:
+            analysis_result = {'Error': f'Invalid token: {e}'}
+        return response

components/menus.py

@@ -0,0 +1,530 @@
+import os
+import platform
+from rich import print
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from GVA.dns_recon import DNSRecon
+from GVA.geo import geo_ip_recon
+from GVA.scanner import NetworkScanner
+from GVA.subdomain import sub_enum
+from GVA.jwt import JWTAnalyzer
+from GVA.assets import Assets
+from GVA.packet_analysis import PacketAnalysis
+from GVA.ai_models import NMAP_AI_MODEL
+from GVA.ai_models import DNS_AI_MODEL
+from GVA.ai_models import JWT_AI_MODEL
+
+assets = Assets()
+dns_enum = DNSRecon()
+geo_ip = geo_ip_recon()
+packetanalysis = PacketAnalysis()
+jwt_analyzer = JWTAnalyzer()
+p_ai_models = NMAP_AI_MODEL()
+dns_ai_models = DNS_AI_MODEL()
+jwt_ai_model = JWT_AI_MODEL()
+port_scanner = NetworkScanner()
+sub_recon = sub_enum()
+console = Console()
+
+
+def clearscr() -> None:
+    try:
+        osp = platform.system()
+        match osp:
+            case 'Darwin':
+                os.system("clear")
+            case 'Linux':
+                os.system("clear")
+            case 'Windows':
+                os.system("cls")
+    except Exception:
+        pass
+
+
+class Menus():
+
+    def nmap_menu(self) -> None:
+        try:
+            table = Table()
+            table.add_column("Options", style="cyan")
+            table.add_column("Utility", style="green")
+            table.add_row("1", "AI Options")
+            table.add_row("2", "Set Target")
+            table.add_row("3", "Set Profile")
+            table.add_row("4", "Show options")
+            table.add_row("5", "Run Attack")
+            table.add_row("q", "Quit")
+            console.print(table)
+            self.option = input("Enter your choice: ")
+            match self.option:
+                case "1":
+                    clearscr()
+                    table0 = Table()
+                    table0.add_column("Options", style="cyan")
+                    table0.add_column("AI Available", style="green")
+                    table0.add_row("1", "OpenAI")
+                    table0.add_row("2", "Bard")
+                    table0.add_row("3", "LLama2")
+                    print(Panel(table0))
+                    self.ai_set_choice = input("Enter AI of Choice: ")
+                    match self.ai_set_choice:
+                        case "1":
+                            self.ai_set_args, self.ai_set = "openai", "openai"
+                            self.akey_set = input("Enter OpenAI API: ")
+                            print(Panel(f"API-Key Set: {self.akey_set}"))
+                        case "2":
+                            self.ai_set_args, self.ai_set = "bard", "bard"
+                            self.bkey_set = input("Enter Bard AI API: ")
+                            print(Panel(f"API-Key Set: {self.bkey_set}"))
+                        case "3":
+                            clearscr()
+                            tablel = Table()
+                            tablel.add_column("Options", style="cyan")
+                            tablel.add_column("Llama Options", style="cyan")
+                            tablel.add_row("1", "Llama Local")
+                            tablel.add_row("2", "Llama RunPod")
+                            print(tablel)
+                            self.ai_set_choice = input("Enter AI of Choice: ")
+                            self.ai_set_args = "llama"
+                            self.ai_set = "llama"
+                            if self.ai_set_choice == "1":
+                                self.ai_set = "llama"
+                                print(Panel("No Key needed"))
+                                print(Panel("Selected LLama"))
+                            elif self.ai_set_choice == "2":
+                                self.ai_set = "llama-api"
+                                self.llamaendpoint = input("Enter Runpod Endpoint ID: ")
+                                self.llamakey = input("Enter Runpod API Key: ")
+                                print(Panel(f"API-Key Set: {self.llamakey}"))
+                                print(Panel(f"Runpod Endpoint Set: {self.llamaendpoint}"))
+                    self.nmap_menu()
+                case "2":
+                    clearscr()
+                    print(Panel("Set Target Hostname or IP"))
+                    self.t = input("Enter Target: ")
+                    print(Panel(f"Target Set: {self.t}"))
+                    self.nmap_menu()
+                case "3":
+                    clearscr()
+                    table1 = Table()
+                    table1.add_column("Options", style="cyan")
+                    table1.add_column("Value", style="green")
+                    table1.add_row("1", "-Pn -sV -T4 -O -F")
+                    table1.add_row("2", "-Pn -T4 -A -v")
+                    table1.add_row("3", "-Pn -sS -sU -T4 -A -v")
+                    table1.add_row("4", "-Pn -p- -T4 -A -v")
+                    table1.add_row("5", "-Pn -sS -sU -T4 -A -PE -PP  -PY -g 53 --script=vuln")
+                    table1.add_row("6", "-Pn -sV -p- -A")
+                    table1.add_row("7", "-Pn -sS -sV -O -T4 -A")
+                    table1.add_row("8", "-Pn -sC")
+                    table1.add_row("9", "-Pn -p 1-65535 -T4 -A -v")
+                    table1.add_row("10", "-Pn -sU -T4")
+                    table1.add_row("11", "-Pn -sV --top-ports 100")
+                    table1.add_row("12", "-Pn -sS -sV -T4 --script=default,discovery,vuln")
+                    table1.add_row("13", "-Pn -F")
+                    print(Panel(table1))
+                    self.profile_num = input("Enter your Profile: ")
+                    print(Panel(f"Profile Set {self.profile_num}"))
+                    self.nmap_menu()
+                case "4":
+                    clearscr()
+                    table2 = Table()
+                    table2.add_column("Options", style="cyan")
+                    table2.add_column("Value", style="green")
+                    table2.add_row("AI Set", str(self.ai_set_args))
+                    table2.add_row("OpenAI API Key", str(self.akey_set))
+                    table2.add_row("Bard AI API Key", str(self.bkey_set))
+                    table2.add_row("Llama Runpod API Key", str(self.llamakey))
+                    table2.add_row("Runpod Endpoint ID", str(self.llamaendpoint))
+                    table2.add_row("Target", str(self.t))
+                    table2.add_row("Profile", str(self.profile_num))
+                    print(Panel(table2))
+                    self.nmap_menu()
+                case "5":
+                    clearscr()
+                    pout: str = port_scanner.scanner(
+                        AIModels=p_ai_models,
+                        ip=self.t,
+                        profile=int(self.profile_num),
+                        akey=self.akey_set,
+                        bkey=self.bkey_set,
+                        lkey=self.lkey,
+                        lendpoint=self.lendpoint,
+                        AI=self.ai_set
+                    )
+                    assets.print_output("Nmap", pout, self.ai_set)
+                case "q":
+                    quit()
+        except KeyboardInterrupt:
+            print(Panel("Exiting Program"))
+
+    def dns_menu(self) -> None:
+        try:
+            table = Table()
+            table.add_column("Options", style="cyan")
+            table.add_column("Utility", style="green")
+            table.add_row("1", "AI Option")
+            table.add_row("2", "Set Target")
+            table.add_row("3", "Show options")
+            table.add_row("4", "Run Attack")
+            table.add_row("q", "Quit")
+            console.print(table)
+            option = input("Enter your choice: ")
+            match option:
+                case "1":
+                    clearscr()
+                    table0 = Table()
+                    table0.add_column("Options", style="cyan")
+                    table0.add_column("AI Available", style="green")
+                    table0.add_row("1", "OpenAI")
+                    table0.add_row("2", "Bard")
+                    table0.add_row("3", "LLama2")
+                    print(Panel(table0))
+                    self.ai_set_choice = input("Enter AI of Choice: ")
+                    match self.ai_set_choice:
+                        case "1":
+                            self.ai_set_args, self.ai_set = "openai", "openai"
+                            self.akey_set = input("Enter OpenAI API: ")
+                            print(Panel(f"API-Key Set: {self.akey_set}"))
+                        case "2":
+                            self.ai_set_args, self.ai_set = "bard", "bard"
+                            self.bkey_set = input("Enter Bard AI API: ")
+                            print(Panel(f"API-Key Set: {self.bkey_set}"))
+                        case "3":
+                            clearscr()
+                            tablel = Table()
+                            tablel.add_column("Options", style="cyan")
+                            tablel.add_column("Llama Options", style="cyan")
+                            tablel.add_row("1", "Llama Local")
+                            tablel.add_row("2", "Llama RunPod")
+                            print(tablel)
+                            self.ai_set_choice = input("Enter AI of Choice: ")
+                            self.ai_set_args = "llama"
+                            self.ai_set = "llama"
+                            if self.ai_set_choice == "1":
+                                self.ai_set = "llama"
+                                print(Panel("No Key needed"))
+                                print(Panel("Selected LLama"))
+                            elif self.ai_set_choice == "2":
+                                self.ai_set = "llama-api"
+                                self.llamaendpoint = input("Enter Runpod Endpoint ID: ")
+                                self.llamakey = input("Enter Runpod API Key: ")
+                                print(Panel(f"API-Key Set: {self.llamakey}"))
+                                print(Panel(f"Runpod Endpoint Set: {self.llamaendpoint}"))
+                    self.dns_menu()
+                case "2":
+                    clearscr()
+                    print(Panel("Set Target Hostname or IP"))
+                    self.t = input("Enter Target: ")
+                    print(Panel(f"Target Set:{self.t}"))
+                    self.dns_menu()
+                case "3":
+                    clearscr()
+                    table1 = Table()
+                    table1.add_column("Options", style="cyan")
+                    table1.add_column("Value", style="green")
+                    table1.add_row("AI Set", str(self.ai_set_args))
+                    table1.add_row("OpenAI API Key", str(self.akey_set))
+                    table1.add_row("Bard AI API Key", str(self.bkey_set))
+                    table1.add_row("Llama Runpod API Key", str(self.llamakey))
+                    table1.add_row("Runpod Endpoint ID", str(self.llamaendpoint))
+                    table1.add_row("Target", str(self.t))
+                    print(Panel(table1))
+                    self.dns_menu()
+                case "4":
+                    clearscr()
+                    dns_output: str = dns_enum.dns_resolver(
+                        AIModels=dns_ai_models,
+                        target=self.t,
+                        akey=self.akey_set,
+                        bkey=self.bkey_set,
+                        lkey=self.lkey,
+                        lendpoint=self.lendpoint,
+                        AI=self.ai_set
+                    )
+                    assets.print_output("DNS", dns_output, self.ai_set)
+                case "q":
+                    quit()
+        except KeyboardInterrupt:
+            print(Panel("Exiting Program"))
+
+    def jwt_menu(self) -> None:
+        try:
+            table = Table()
+            table.add_column("Options", style="cyan")
+            table.add_column("Utility", style="green")
+            table.add_row("1", "AI Option")
+            table.add_row("2", "Set Token")
+            table.add_row("3", "Show options")
+            table.add_row("4", "Run Attack")
+            table.add_row("q", "Quit")
+            console.print(table)
+            option = input("Enter your choice: ")
+            match option:
+                case "1":
+                    clearscr()
+                    table0 = Table()
+                    table0.add_column("Options", style="cyan")
+                    table0.add_column("AI Available", style="green")
+                    table0.add_row("1", "OpenAI")
+                    table0.add_row("2", "Bard")
+                    table0.add_row("3", "LLama2")
+                    print(Panel(table0))
+                    self.ai_set_choice = input("Enter AI of Choice: ")
+                    match self.ai_set_choice:
+                        case "1":
+                            self.ai_set_args, self.ai_set = "openai", "openai"
+                            self.akey_set = input("Enter OpenAI API: ")
+                            print(Panel(f"API-Key Set: {self.akey_set}"))
+                        case "2":
+                            self.ai_set_args, self.ai_set = "bard", "bard"
+                            self.bkey_set = input("Enter Bard AI API: ")
+                            print(Panel(f"API-Key Set: {self.bkey_set}"))
+                        case "3":
+                            clearscr()
+                            tablel = Table()
+                            tablel.add_column("Options", style="cyan")
+                            tablel.add_column("Llama Options", style="cyan")
+                            tablel.add_row("1", "Llama Local")
+                            tablel.add_row("2", "Llama RunPod")
+                            print(tablel)
+                            self.ai_set_choice = input("Enter AI of Choice: ")
+                            self.ai_set_args = "llama"
+                            self.ai_set = "llama"
+                            if self.ai_set_choice == "1":
+                                self.ai_set = "llama"
+                                print(Panel("No Key needed"))
+                                print(Panel("Selected LLama"))
+                            elif self.ai_set_choice == "2":
+                                self.ai_set = "llama-api"
+                                self.llamaendpoint = input("Enter Runpod Endpoint ID: ")
+                                self.llamakey = input("Enter Runpod API Key: ")
+                                print(Panel(f"API-Key Set: {self.llamakey}"))
+                                print(Panel(f"Runpod Endpoint Set: {self.llamaendpoint}"))
+                    self.jwt_menu()
+                case "2":
+                    clearscr()
+                    print(Panel("Set Token value"))
+                    self.t = input("Enter TOKEN: ")
+                    print(Panel(f"Token Set:{self.t}"))
+                    self.jwt_menu()
+                case "3":
+                    clearscr()
+                    table1 = Table()
+                    table1.add_column("Options", style="cyan")
+                    table1.add_column("Value", style="green")
+                    table1.add_row("AI Set", str(self.ai_set_args))
+                    table1.add_row("OpenAI API Key", str(self.akey_set))
+                    table1.add_row("Bard AI API Key", str(self.bkey_set))
+                    table1.add_row("Llama Runpod API Key", str(self.llamakey))
+                    table1.add_row("Runpod Endpoint ID", str(self.llamaendpoint))
+                    table1.add_row("JWT TOKEN", str(self.t))
+                    print(Panel(table1))
+                    self.jwt_menu()
+                case "4":
+                    clearscr()
+                    JWT_output: str = jwt_analyzer.analyze(
+                        AIModels=jwt_ai_model,
+                        token=self.t,
+                        openai_api_token=self.akey_set,
+                        bard_api_token=self.bkey_set,
+                        llama_api_token=self.lkey,
+                        llama_endpoint=self.lendpoint,
+                        AI=self.ai_set
+                    )
+                    assets.print_output("JWT", JWT_output, self.ai_set)
+                case "q":
+                    quit()
+        except KeyboardInterrupt:
+            print(Panel("Exiting Program"))
+
+    def pcap_menu(self) -> None:
+        try:
+            table = Table()
+            table.add_column("Options", style="cyan")
+            table.add_column("Utility", style="green")
+            table.add_row("1", "Set Target file location")
+            table.add_row("2", "Set Output file location")
+            table.add_row("3", "Set Threads")
+            table.add_row("4", "Show options")
+            table.add_row("5", "Run Attack")
+            table.add_row("q", "Quit")
+            console.print(table)
+            self.option = input("Enter your choice: ")
+            match self.option:
+                case "1":
+                    clearscr()
+                    print(Panel("Set Target PCAP file Location"))
+                    self.t = input("Enter Target: ")
+                    print(Panel(f"Target Set: {self.t}"))
+                    self.pcap_menu()
+                case "2":
+                    clearscr()
+                    print(Panel("Set Output file Location"))
+                    self.t = input("Enter Location: ")
+                    print(Panel(f"Output Set: {self.output_loc}"))
+                    self.pcap_menu()
+                case "3":
+                    clearscr()
+                    print(Panel("Set Number of threads"))
+                    self.t = input("Enter Threads: ")
+                    print(Panel(f"Threads Set: {self.threads}"))
+                    self.pcap_menu()
+                case "4":
+                    clearscr()
+                    table1 = Table()
+                    table1.add_column("Options", style="cyan")
+                    table1.add_column("Value", style="green")
+                    table1.add_row("Target PCAP file", str(self.t))
+                    table1.add_row("Output location", str(self.output_loc))
+                    table1.add_row("Threads set", str(self.threads))
+                    print(Panel(table1))
+                    self.pcap_menu()
+                case "5":
+                    clearscr()
+                    packetanalysis.PacketAnalyzer(
+                        cap_loc=self.t,
+                        save_loc=self.output_loc,
+                        max_workers=self.threads
+                    )
+                case "q":
+                    quit()
+        except KeyboardInterrupt:
+            print(Panel("Exiting Program"))
+
+    def geo_menu(self) -> None:
+        try:
+            table = Table()
+            table.add_column("Options", style="cyan")
+            table.add_column("Utility", style="green")
+            table.add_row("1", "ADD API Key")
+            table.add_row("2", "Set Target")
+            table.add_row("3", "Show options")
+            table.add_row("4", "Run Attack")
+            table.add_row("q", "Quit")
+            console.print(table)
+            self.option = input("Enter your choice: ")
+            match self.option:
+                case "1":
+                    clearscr()
+                    self.keyset = input("Enter GEO-IP API: ")
+                    print(Panel(f"GEOIP API Key Set: {self.keyset}"))
+                    self.geo_menu()
+                case "2":
+                    clearscr()
+                    print(Panel("Set Target Hostname or IP"))
+                    self.t = input("Enter Target: ")
+                    print(Panel(f"Target Set: {self.t}"))
+                    self.geo_menu()
+                case "3":
+                    clearscr()
+                    table1 = Table()
+                    table1.add_column("Options", style="cyan")
+                    table1.add_column("Value", style="green")
+                    table1.add_row("API Key", str(self.keyset))
+                    table1.add_row("Target", str(self.t))
+                    print(Panel(table1))
+                    self.geo_menu()
+                case "4":
+                    clearscr()
+                    geo_output: str = geo_ip.geoip(self.keyset, self.t)
+                    assets.print_output("GeoIP", str(geo_output), ai="None")
+                case "q":
+                    quit()
+        except KeyboardInterrupt:
+            print(Panel("Exiting Program"))
+
+    def sub_menu(self) -> None:
+        try:
+            table = Table()
+            table.add_column("Options", style="cyan")
+            table.add_column("Utility", style="green")
+            table.add_row("1", "ADD Subdomain list")
+            table.add_row("2", "Set Target")
+            table.add_row("3", "Show options")
+            table.add_row("4", "Run Attack")
+            table.add_row("q", "Quit")
+            console.print(table)
+            self.option = input("Enter your choice: ")
+            match self.option:
+                case "1":
+                    clearscr()
+                    print(Panel("Set TXT subdomain file location"))
+                    self.list_loc = input("Enter List Location:  ")
+                    print(Panel(f"Location Set: {self.list_loc}"))
+                    self.sub_menu()
+                case "2":
+                    clearscr()
+                    print(Panel("Set Target Hostname or IP"))
+                    self.t = input("Enter Target: ")
+                    print(Panel(f"Target Set: {self.t}"))
+                    self.sub_menu()
+                case "3":
+                    clearscr()
+                    table1 = Table()
+                    table1.add_column("Options", style="cyan")
+                    table1.add_column("Value", style="green")
+                    table1.add_row("Location", str(self.list_loc))
+                    table1.add_row("Target", str(self.t))
+                    print(Panel(table1))
+                    self.sub_menu()
+                case "4":
+                    clearscr()
+                    sub_output: str = sub_recon.sub_enumerator(self.t, self.list_loc)
+                    console.print(sub_output, style="bold underline")
+                case "q":
+                    quit()
+        except KeyboardInterrupt:
+            print(Panel("Exiting Program"))
+
+    def __init__(self, lkey, threads, output_loc, lendpoint, keyset, t, profile_num, ai_set, akey_set, bkey_set, ai_set_args, llamakey, llamaendpoint) -> None:
+        try:
+            self.lkey = lkey
+            self.threads = threads
+            self.output_loc = output_loc
+            self.lendpoint = lendpoint
+            self.keyset = keyset
+            self.t = t
+            self.profile_num = profile_num
+            self.ai_set = ai_set
+            self.akey_set = akey_set
+            self.bkey_set = bkey_set
+            self.ai_set_args = ai_set_args
+            self.llamakey = llamakey
+            self.llamaendpoint = llamaendpoint
+            table = Table()
+            table.add_column("Options", style="cyan")
+            table.add_column("Utility", style="green")
+            table.add_row("1", "Nmap Enum")
+            table.add_row("2", "DNS Enum")
+            table.add_row("3", "Subdomain Enum")
+            table.add_row("4", "GEO-IP Enum")
+            table.add_row("5", "JWT Analysis")
+            table.add_row("6", "PCAP Analysis")
+            table.add_row("q", "Quit")
+            console.print(table)
+            option = input("Enter your choice: ")
+            match option:
+                case "1":
+                    clearscr()
+                    self.nmap_menu()
+                case "2":
+                    clearscr()
+                    self.dns_menu()
+                case "3":
+                    clearscr()
+                    self.sub_menu()
+                case "4":
+                    clearscr()
+                    self.geo_menu()
+                case "5":
+                    clearscr()
+                    self.jwt_menu()
+                case "6":
+                    clearscr()
+                    self.pcap_menu()
+                case "q":
+                    quit()
+        except KeyboardInterrupt:
+            print(Panel("Exiting Program"))

components/packet_analysis.py

@@ -0,0 +1,218 @@
+from rich import print
+from subprocess import run, PIPE, STDOUT
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any
+from rich.console import Console
+from rich.table import Table
+import json
+import re
+import platform
+
+
+class PacketAnalysis:
+    tshark_loc = ""
+    services = []
+    tcp_streams = []
+    sources = []
+    destinations = []
+    resolved = []
+    dns_query_names = []
+    dns_resp_names = []
+    unique_eapol_data = []
+    combined_json = []
+
+    def detect_tshark(self) -> None:
+        try:
+            osp = platform.system()
+            match osp:
+                case 'Darwin':
+                    self.tshark_loc = "tshark"
+                case 'Linux':
+                    self.tshark_loc = "tshark"
+                case 'Windows':
+                    self.tshark_loc = '"C:\\Program Files\\Wireshark\\tshark.exe"'
+        except Exception:
+            pass
+
+    def extract_network_info(self, json_data):
+        services = set()
+        tcp_streams = set()
+        source_addresses = set()
+        destination_addresses = set()
+        resolved_sources = set()
+        dns_query_names = set()
+        dns_resp_names = set()
+        unique_eapol_data = set()
+
+        for entry in json_data:
+            layers = entry.get('_source', {}).get('layers', {})
+
+            tcp_layer = layers.get('tcp', {})
+            if tcp_layer:
+                service = tcp_layer.get('tcp.srcport')
+                if service:
+                    services.add(service)
+            if tcp_layer:
+                tcp_stream_val = tcp_layer.get('tcp.stream')
+                if service:
+                    tcp_streams.add(tcp_stream_val)
+
+            ip_layer = layers.get('ip', {})
+            if ip_layer:
+                source_address = ip_layer.get('ip.src_host')
+                destination_address = ip_layer.get('ip.dst_host')
+                if source_address:
+                    source_addresses.add(source_address)
+                if destination_address:
+                    destination_addresses.add(destination_address)
+
+            eth_layer = layers.get('eth', {})
+            if eth_layer:
+                source_mac = eth_layer.get('eth.src')
+                resolved_source_mac = eth_layer.get('eth.src_tree', {}).get('eth.src_resolved')
+                if source_mac and resolved_source_mac:
+                    resolved_sources.add(resolved_source_mac)
+
+            dns_layer = layers.get('dns', {})
+            if dns_layer:
+                queries = dns_layer.get('Queries', [])
+                if isinstance(queries, list):
+                    for query in queries:
+                        query_name = query.get('dns.qry.name')
+                        if query_name:
+                            dns_query_names.add(query_name)
+                elif isinstance(queries, dict):
+                    for query_name, query_info in queries.items():
+                        dns_query_names.add(query_info.get('dns.qry.name'))
+                answers = dns_layer.get('Answers', [])
+                if isinstance(answers, list):
+                    for answer in answers:
+                        resp_name = answer.get('dns.resp.name')
+                        if resp_name:
+                            dns_resp_names.add(resp_name)
+                elif isinstance(answers, dict):
+                    for resp_name, resp_info in answers.items():
+                        dns_resp_names.add(resp_info.get('dns.resp.name'))
+
+            eapol_layer = layers.get('eapol', {})
+            if eapol_layer:
+                eapol_data = eapol_layer.get('wlan_rsna_eapol.keydes.data', "")
+                unique_eapol_data.add(eapol_data)
+
+        self.services = list(services)
+        self.tcp_streams = list(tcp_streams)
+        self.source_addresses = list(source_addresses)
+        self.destination_addresses = list(destination_addresses)
+        self.resolved_sources = list(resolved_sources)
+        self.dns_query_names = list(dns_query_names)
+        self.dns_resp_names = list(dns_resp_names)
+        self.unique_eapol_data = list(unique_eapol_data)
+
+    def run_tshark_command(self, service, source, streams):
+        stream_cmd = f'{self.tshark_loc} -r test.pcap -q -z follow,tcp,raw,{streams} -Y "ip.addr=={source} and tcp.port=={service}"'
+        runner = run(stream_cmd, shell=True, stdout=PIPE, stderr=STDOUT, text=True)
+        output_lines = runner.stdout.splitlines()
+        node_regex = re.compile(r'Node (\d+): (.+)$')
+        data_regex = re.compile(r'\s+(.+)$')
+        node_0, node_1, data = None, None, None
+        for line in output_lines:
+            node_match = node_regex.match(line)
+            data_match = data_regex.match(line)
+            if node_match:
+                node_num, node_value = node_match.groups()
+                if node_num == '0':
+                    node_0 = node_value
+                elif node_num == '1':
+                    node_1 = node_value
+            elif data_match:
+                data = data_match.group(1)
+
+        if node_0 is not None and node_1 is not None and data is not None:
+            return ['Source: ' f'{node_0}', 'Destination: ' f'{node_1}', 'stream: ' f'{streams}']
+        else:
+            return []
+
+    def flatten_json(self, data: Any, separator: Any = '.') -> Any:
+        flattened_data = {}
+        for key, value in data.items():
+            if isinstance(value, dict):
+                nested_data = self.flatten_json(value, separator)
+                for nested_key, nested_value in nested_data.items():
+                    flattened_data[key + separator + nested_key] = nested_value
+            else:
+                flattened_data[key] = value
+        return flattened_data
+
+    def stream(self, service_list, source_list, tcp_streams_list, max_workers=20):
+        results = []
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            command_params = [(service, source, streams) for service in service_list for source in source_list for streams in tcp_streams_list]
+            print("Total Streams combination: ", len(command_params))
+            print("Number of workers in progress: ", max_workers)
+            results = list(executor.map(lambda params: self.run_tshark_command(*params), command_params))
+        results = [result for result in results if result]
+        self.combined_json = results
+
+    def PacketAnalyzer(self, cap_loc, save_loc, max_workers):
+        self.detect_tshark()
+        print('Collecting Json Data')
+        raw_pcap = run(f"{self.tshark_loc} -r {cap_loc} -T json", shell=True, capture_output=True, text=True)
+        try:
+            raw_data = raw_pcap.stdout
+            json_data = json.loads(raw_data)
+        except json.JSONDecodeError as e:
+            print(f"Error decoding JSON: {e}")
+            json_data = []
+        print('Extracting IP details...')
+        print('Extracting DNS details...')
+        print('Extracting EAPOL details...')
+        self.extract_network_info(json_data)
+        print('Extracting TCP STREAMS details...')
+        print('TCP streams can take some time..')
+        self.stream(service_list=self.services,
+                    source_list=self.source_addresses,
+                    tcp_streams_list=self.tcp_streams,
+                    max_workers=max_workers)
+        print("Completed")
+        filtered_stream_data = self.combined_json
+        values = {
+            "PacketAnalysis": {
+                "Services": self.services,
+                "TCP Streams": self.tcp_streams,
+                "Sources Address": self.source_addresses,
+                "Destination Address": self.destination_addresses,
+                "DNS Resolved": self.resolved,
+                "DNS Query": self.dns_query_names,
+                "DNS Response": self.dns_resp_names,
+                "EAPOL Data": self.unique_eapol_data,
+                "Stream Data": filtered_stream_data
+            }
+        }
+        table_val = {
+            "PacketAnalysis": {
+                "Services": self.services,
+                "TCP Streams": self.tcp_streams,
+                "Sources Address": self.source_addresses,
+                "Destination Address": self.destination_addresses,
+                "DNS Resolved": self.resolved,
+                "DNS Query": self.dns_query_names,
+                "DNS Response": self.dns_resp_names,
+                "EAPOL Data": self.unique_eapol_data,
+                " Total Streams Data": str(len(filtered_stream_data))
+            }
+        }
+        table = Table(title="GVA Report for PCAP", show_header=True, header_style="bold magenta")
+        table.add_column("Identifiers", style="cyan")
+        table.add_column("Data", style="green")
+
+        flattened_data: dict = self.flatten_json(table_val, separator='.')
+
+        for key, value in flattened_data.items():
+            value_str = str(value)
+            table.add_row(key, str(value_str))
+
+        console = Console()
+        console.print(table)
+        with open(f'{save_loc}', 'w+') as file:
+            file.write(str(json.dumps(values)))

components/passbeaker.py

@@ -1,9 +1,3 @@
-import hashlib
-import argparse
-import itertools
-from multiprocessing import Pool
-
-
 class PasswordCracker:
     def __init__(self, password_hash, wordlist_file, algorithm, salt=None, parallel=False, complexity_check=False):
         self.password_hash = password_hash
@@ -12,114 +6,15 @@ class PasswordCracker:
         self.salt = salt
         self.parallel = parallel
         self.complexity_check = complexity_check
-        self.total_passwords = 0
-        self.matched_password = None
-
-    def crack_hash(self, word):
-        if self.salt:
-            word_with_salt = f'{self.salt}{word}'
-        else:
-            word_with_salt = word
-        hashed_word = hashlib.new(self.algorithm, word_with_salt.encode()).hexdigest()
-        if hashed_word == self.password_hash:
-            self.matched_password = word
-            return True
-        return False
-
-    def generate_passwords(self, min_length, max_length, character_set):
-        passwords = []
-        for length in range(min_length, max_length + 1):
-            for combination in itertools.product(character_set, repeat=length):
-                password = ''.join(combination)
-                passwords.append(password)
-        return passwords
-
-    def evaluate_complexity(self, password):
-        has_lowercase = False
-        has_uppercase = False
-        has_digit = False
-        has_special = False
-
-        for char in password:
-            if char.islower():
-                has_lowercase = True
-            elif char.isupper():
-                has_uppercase = True
-            elif char.isdigit():
-                has_digit = True
-            else:
-                has_special = True
-
-        if len(password) >= 8 and has_lowercase and has_uppercase and has_digit and has_special:
-            return True
-        return False
-
-    def crack_passwords(self, passwords):
-        for password in passwords:
-            self.total_passwords += 1
-            if self.crack_hash(password):
-                break
-
-    def crack_passwords_parallel(self, passwords):
-        pool = Pool()
-        pool.map(self.crack_password, passwords)
-        pool.close()
-
-    def crack_password(self, password):
-        if self.complexity_check and not self.evaluate_complexity(password):
-            return
-        if self.matched_password is None:
-            if self.crack_hash(password):
-                return
 
     def crack_passwords_with_wordlist(self):
-        with open(self.wordlist_file, 'r', encoding="latin-1") as wordlist:
-            passwords = wordlist.read().splitlines()
-            if self.parallel:
-                self.crack_passwords_parallel(passwords)
-            else:
-                self.crack_passwords(passwords)
+        # ?????? ??? ??????? ?????? ?? ???????
+        pass
 
     def crack_passwords_with_brute_force(self, min_length, max_length, character_set):
-        passwords = self.generate_passwords(min_length, max_length, character_set)
-        if self.parallel:
-            self.crack_passwords_parallel(passwords)
-        else:
-            self.crack_passwords(passwords)
-
-    def print_statistics(self):
-        print(f"Total Number of Passwords Tried: {self.total_passwords}")
-        if self.matched_password:
-            print(f"Password Cracked! Password: {self.matched_password}")
-        else:
-            print("Password Failed.")
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Password cracking source PassBreaker')
-    parser.add_argument('password_hash', help='Password hash')
-    parser.add_argument('wordlist_file', help='Wordlist File')
-    parser.add_argument('--algorithm', choices=hashlib.algorithms_guaranteed, required=True, help='Hash algorithm')
-    parser.add_argument('-s', '--salt', help='Salt Value')
-    parser.add_argument('-p', '--parallel', action='store_true', help='Use parallel processing')
-    parser.add_argument('-c', '--complexity', action='store_true', help='Check for password complexity')
-    parser.add_argument('-b', '--brute-force', action='store_true', help='Perform a brute force attack')
-    parser.add_argument('--min-length', type=int, default=1, help='Minimum password length for brute force attack')
-    parser.add_argument('--max-length', type=int, default=6, help='Minimum password length for brute force attack')
-    parser.add_argument('--character-set', default='abcdefghijklmnopqrstuvwxyz0123456789',
-                        help='Character set for brute force attack')
-
-    args = parser.parse_args()
-
-    cracker = PasswordCracker(args.password_hash, args.wordlist_file, args.algorithm, args.salt, args.parallel, args.complexity)
-
-    if args.brute_force:
-        cracker.crack_passwords_with_brute_force(args.min_length, args.max_length, args.character_set)
-    else:
-        cracker.crack_passwords_with_wordlist()
-
-    cracker.print_statistics()
-
+        # ?????? ??? ??????? ?????? ??????? ????????
+        pass
 
-if __name__ == '__main__':
-    main()
+    def get_statistics(self):
+        # ????? ??? ????????? ??????????
+        return "Statistics data"

components/requirements.txt

@@ -0,0 +1,20 @@
+aiohttp==3.8.4
+aiosignal==1.3.1
+async-timeout==4.0.2
+attrs==22.2.0
+certifi==2022.12.7
+charset-normalizer==3.0.1
+frozenlist==1.3.3
+idna==3.4
+multidict==6.0.4
+openai==0.27.0
+python-nmap==0.7.1
+requests==2.28.2
+tqdm==4.65.0
+urllib3==1.26.14
+yarl==1.8.2
+dnspython
+rich
+cowsay
+tk
+customtkinter

components/scanner.py

@@ -0,0 +1,63 @@
+from typing import Optional
+
+import nmap
+nm = nmap.PortScanner()
+
+
+class NetworkScanner():
+    def scanner(self, AIModels, ip: Optional[str], profile: int, akey: Optional[str], bkey: Optional[str], lkey, lendpoint, AI: str) -> str:
+        profile_arguments = {
+            1: '-Pn -sV -T4 -O -F',
+            2: '-Pn -T4 -A -v',
+            3: '-Pn -sS -sU -T4 -A -v',
+            4: '-Pn -p- -T4 -A -v',
+            5: '-Pn -sS -sU -T4 -A -PE -PP  -PY -g 53 --script=vuln',
+            6: '-Pn -sV -p- -A',
+            7: '-Pn -sS -sV -O -T4 -A',
+            8: '-Pn -sC',
+            9: '-Pn -p 1-65535 -T4 -A -v',
+            10: '-Pn -sU -T4',
+            11: '-Pn -sV --top-ports 100',
+            12: '-Pn -sS -sV -T4 --script=default,discovery,vuln',
+            13: '-Pn -F'
+        }
+        # The scanner with GPT Implemented
+        nm.scan('{}'.format(ip), arguments='{}'.format(profile_arguments.get(profile)))
+        json_data = nm.analyse_nmap_xml_scan()
+        analyze = json_data["scan"]
+        match AI:
+            case 'openai':
+                try:
+                    if akey is not None:
+                        pass
+                    else:
+                        raise ValueError("KeyNotFound: Key Not Provided")
+                    response = AIModels.GPT_AI(akey, analyze)
+                except KeyboardInterrupt:
+                    print("Bye")
+                    quit()
+            case 'bard':
+                try:
+                    if bkey is not None:
+                        pass
+                    else:
+                        raise ValueError("KeyNotFound: Key Not Provided")
+                    response = AIModels.BardAI(bkey, analyze)
+                except KeyboardInterrupt:
+                    print("Bye")
+                    quit()
+            case 'llama':
+                try:
+                    response = AIModels.Llama_AI(analyze, "local", lkey, lendpoint)
+                except KeyboardInterrupt:
+                    print("Bye")
+                    quit()
+            case 'llama-api':
+                try:
+                    response = AIModels.Llama_AI(analyze, "runpod", lkey, lendpoint)
+                except KeyboardInterrupt:
+                    print("Bye")
+                    quit()
+        self.response = response
+        text = str(self.response)
+        return text

components/subdomain.py

@@ -0,0 +1,44 @@
+import dns.resolver
+from rich.console import Console
+from rich.progress import track
+from rich.table import Table
+
+console = Console()
+
+
+class sub_enum():
+    def display_urls(sd_data: list[str], count: int) -> None:
+        console = Console()
+        table = Table(title=f"GVA Subdomain report. found out of {count}", show_header=True, header_style="bold")
+        table.add_column("Index", justify="right", style="cyan")
+        table.add_column("URL", style="green")
+        for index, url in enumerate(sd_data):
+            table.add_row(str(index), url)
+        console.print(table)
+
+    def sub_enumerator(self, target: str, list: str) -> str:
+        sd_data = []
+        s_array = []
+        count: int = 0
+        with open(list, "r") as file:
+            for line in file:
+                subdomain_key = line.strip()
+                s_array.append(subdomain_key)
+        for subd in track(s_array):
+            try:
+                ip_value = dns.resolver.resolve(f'{subd}.{target}', 'A')
+                if ip_value:
+                    sd_data.append(f'{subd}.{target}')
+                    if f"{subd}.{target}" in sd_data:
+                        count = count + 1
+                    else:
+                        pass
+            except dns.resolver.NXDOMAIN:
+                pass
+            except dns.resolver.NoAnswer:
+                pass
+            except KeyboardInterrupt:
+                print('Ended')
+                quit()
+        self.display_urls(sd_data, count)
+        return 'Done'