import src.nvd_fetcher as get_nvd

import src.epss_fetcher as get_epss

import src.zdi_fetcher as get_zdi

import src.cisa_kev_fetcher as get_cisa_kev

import src.googlepz_fetcher as get_google_pz

import src.inthewild_fetcher as get_inthewild

import src.fetch_ttp_from_cwe as ttp_cwe

import src.fetch_advisories_from_ttp as adv_ttp

import json

from pathlib import Path

import argparse

from pathlib import Path

import time

results = []

def extractor_nvd(cve, nvd_results):

# print(nvd_results)

def extractor_number_cpe(cve_id, nvd_results):

return impact

def calc_cpe_impact(cve_id, num_cpe):

return impact

def extractor_number_cwe(cve_id, nvd_results):

return cve_cwe_counts

def calc_cwe_impact(cve_id, num_cwe):

return impact

def extractor_advisories(cve_id, cwe_data):

return impact

def calc_advisories_impact(cve_id, total_num_adv):

return impact

def extractor_epss(cve_id, epss_json_result):

return None, None

def extractor_zdi(cve_id, zdi_results):

# print(is_present, "\n")

def extractor_kev(cve_id, kev_results):

return kev_results[cve_id]

def extractor_google_pz(cve_id, google_pz_results):

return google_pz_results[cve_id]

def extractor_inthewild(cve_id, inthewild_results):

# print(inthewild_results)

def calculator(temporal_score, impact_sub_score, exploitability_sub_score, cpe_impact, cwe_impact, adv_impact, epss_score, exploited_in_wild, cisa_kev, zdi, epss_percentile):

return final_score

def call_calculator(Temporal_Score, Impact_Sub_Score, Exploitability_Sub_Score, impact_of_cpe, impact_of_cwe, impact_of_adv, epss_score, is_google_pz, is_inthewild, is_kev, is_zdi, epss_percentile):

return final_score

def load_cves_from_file(file_path):

raise ValueError("Unsupported file format. Use .json or .txt files.")

def load_cves_from_directory(directory_path):

return cves

def write_config_file(config_file, base_dir, cves, sort_order):

json.dump(config, f, indent=2)

def read_config_file(config_file):

# ]

if __name__ == "__main__":

# Argument parser setup

start_time = time.time()

parser = argparse.ArgumentParser(description="CVE Processing Script")

parser.add_argument('--cve_list', help="Comma-separated list of CVEs", type=str)

parser.add_argument('--cve_file', help="Path to a JSON file containing CVEs", type=str)

parser.add_argument('--cve_dir', help="Directory containing files with CVEs", type=str)

parser.add_argument('--base_dir', help="Base directory", required=True, type=str)

parser.add_argument('--sort_order', help="Sort order: ascending or descending", choices=['ascending', 'descending'], default='descending')

parser.add_argument('--config', help="Path to a config file", type=str)

parser.add_argument('--write_config', help="Write configuration to a file", type=str)

parser.add_argument('--outfile', help="Output JSON file name (default: results.json)", type=str, default="results.json")

parser.add_argument('--nvd_threads', help="Number of threads NVD Fetcher will use to get data", type=int, default=10, required=True)

args = parser.parse_args()

# Load base_dir and cve list from config if provided

if args.config:

config = read_config_file(args.config)

base_dir = config.get('base_dir', args.base_dir)

cves = config.get('cves', [])

sort_order = config.get('sort_order', args.sort_order)

else:

base_dir = args.base_dir

sort_order = args.sort_order

cves = []

# Load CVEs based on provided options

if args.cve_list:

cves += args.cve_list.split(',')

if args.cve_file:

cves += load_cves_from_file(Path(args.cve_file))

if args.cve_dir:

cves += load_cves_from_directory(Path(args.cve_dir))

# Ensure there are no duplicates

cves = list(set(cves))

# Store the results for all CVEs in a list of dictionaries

cve_results = []

# INITIAL FETCHES (adjust the following functions according to your implementation) ----------

# NVD Part

scores, nvd_results = get_nvd.fetch_multiple_cves(base_dir, cves, args.nvd_threads)

print(scores)

epss_result = get_epss.fetch_multiple_epss(base_dir, cves)

epss_json_result = json.dumps(epss_result, indent=2)

zdi_results = get_zdi.fetch_multiple_cves_from_zdi(cves, base_dir + '/zdi_rss_feeds')

kev_file = Path(base_dir) / "cisa_kev" / "known_exploited_vulnerabilities.json"

kev_data = get_cisa_kev.load_kev_data(kev_file)

kev_results = get_cisa_kev.check_multiple_cves_in_kev(kev_data, cves)

google_pz_results = get_google_pz.fetch_multiple_cves(base_dir, cves)

inthewild_results = get_inthewild.fetch_inthewild_from_file(cves, base_dir + "/inthewild/")

# Function Caller

for cve_id in cves:

Base_Score, Exploitability_Sub_Score, Impact_Sub_Score, Temporal_Score = extractor_nvd(cve_id, scores)

print("~"*20, Base_Score, Exploitability_Sub_Score, Impact_Sub_Score, Temporal_Score, "~"*20)

if Base_Score !=None and Exploitability_Sub_Score !=None and Impact_Sub_Score!=None and Temporal_Score !=None:

epss_score, epss_percentile = extractor_epss(cve_id, epss_json_result)

print(epss_score, epss_percentile)

if epss_score !=None and epss_percentile !=None:

is_zdi = extractor_zdi(cve_id, zdi_results)

is_kev = extractor_kev(cve_id, kev_results)

is_google_pz = extractor_google_pz(cve_id, google_pz_results)

is_inthewild = extractor_inthewild(cve_id, inthewild_results)

impact_of_cpe = extractor_number_cpe(cve_id, nvd_results)

cwe_data, impact_of_cwe = extractor_number_cwe(cve_id, nvd_results)

impact_of_adv = extractor_advisories(cve_id, cwe_data)

if Base_Score !=None and Exploitability_Sub_Score !=None and Impact_Sub_Score!=None and Temporal_Score !=None:

# CALL TO CALCULATOR

final_Score = call_calculator(Temporal_Score, Impact_Sub_Score, Exploitability_Sub_Score, impact_of_cpe, impact_of_cwe, impact_of_adv, epss_score, is_google_pz, is_inthewild, is_kev, is_zdi, epss_percentile)

# Append the results for this CVE to the cve_results list

cve_results.append({

"CVE_ID": cve_id,

"Status": "Success",

"Exploitability_Sub_Score": Exploitability_Sub_Score,

"Temporal_Score": Temporal_Score,

"Impact_Sub_Score": Impact_Sub_Score,

"EPSS_Score": epss_score,

"EPSS_Percentile": epss_percentile,

"ZDI_Presence": is_zdi,

"KEV_Presence": is_kev,

"Google_Project_Zero_Presence": is_google_pz,

"In_The_Wild": is_inthewild,

"CPE_Impact": impact_of_cpe,

"CWE_Impact": impact_of_cwe,

"Advisories_Impact": impact_of_adv,

"Final_Score": final_Score

})

else:

cve_results.append({

"CVE_ID": cve_id,

"Status": "Failure",

"Reason": "Not Enough Data Found!",

"Final_Score": 0

})

# Sort the results by Final_Score

if sort_order == 'ascending':

cve_results = sorted(cve_results, key=lambda x: x["Final_Score"])

else:

cve_results = sorted(cve_results, key=lambda x: x["Final_Score"], reverse=True)

# Write the final sorted JSON result to the output file

print(cve_results)

end_time = time.time()

total_time = end_time - start_time

print(f'Total time taken is: {total_time}')

with open(args.outfile, 'w') as outfile:

json.dump(cve_results, outfile, indent=2)

print(f"Results saved to {args.outfile}")

# Optionally write the configuration to a file

if args.write_config:

write_config_file(args.write_config, base_dir, cves, sort_order)