import json import os import random import pickle import time import datetime import subprocess import argparse import re import multiprocessing import numpy as np from openai import OpenAI from openai import OpenAIError from tqdm import tqdm from functools import partial from datasets import load_dataset from sentence_transformers import SentenceTransformer, CrossEncoder from sklearn.metrics.pairwise import cosine_similarity # client = OpenAI(base_url="http://localhost:11434/v1/", api_key="ollama") client = OpenAI() def load_cache(use_cache): if use_cache and os.path.exists('cache.pkl'): with open('cache.pkl', 'rb') as f: return pickle.load(f) return {} def save_cache(cache, use_cache): if use_cache: with open('cache.pkl', 'wb') as f: pickle.dump(cache, f) def has_all_comments(text): lines=text.split('\n') for line in lines: if line != "" and not line.startswith("#"): return False return True def fetch_dataset_examples(prompt, num_examples=0, use_similarity=False): dataset = load_dataset("patched-codes/synth-vuln-fixes", split="train") if use_similarity: # Load a lightweight model for initial retrieval retrieval_model = SentenceTransformer('all-MiniLM-L6-v2') # Load the cross-encoder model for reranking rerank_model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2') # Extract user messages user_messages = [ next(msg['content'] for msg in item['messages'] if msg['role'] == 'user') for item in dataset ] # Encode the prompt and user messages for initial retrieval prompt_embedding = retrieval_model.encode(prompt, convert_to_tensor=False) corpus_embeddings = retrieval_model.encode(user_messages, convert_to_tensor=False, show_progress_bar=True) # Perform initial retrieval similarities = cosine_similarity([prompt_embedding], corpus_embeddings)[0] top_k = min(100, len(dataset)) top_indices = similarities.argsort()[-top_k:][::-1] # Prepare pairs for reranking rerank_pairs = [[prompt, user_messages[idx]] for idx in top_indices] # Rerank using the cross-encoder model rerank_scores = rerank_model.predict(rerank_pairs) # Sort by reranked score and select top examples reranked_indices = [top_indices[i] for i in np.argsort(rerank_scores)[::-1][:num_examples]] top_indices = reranked_indices else: top_indices = np.random.choice(len(dataset), num_examples, replace=False) few_shot_messages = [] for index in top_indices: py_index = int(index) messages = dataset[py_index]["messages"] dialogue = [msg for msg in messages if msg['role'] != 'system'] few_shot_messages.extend(dialogue) return few_shot_messages def sanitize_filename(name): # Replace ':' with '_', and any other non-alphanumeric characters (except '-' and '_') with '*' sanitized = re.sub(r':', '_', name) sanitized = re.sub(r'[^a-zA-Z0-9\-_]', '*', sanitized) return sanitized def get_semgrep_version(): try: result = subprocess.run(["semgrep", "--version"], capture_output=True, text=True) version = result.stdout.strip().split()[-1] return version except Exception: return "unknown" def get_fixed_code_fine_tuned(prompt, few_shot_messages, model_name): system_message = ( "You are an AI assistant specialized in fixing code vulnerabilities. " "Your task is to provide corrected code that addresses the reported security issue. " "Always maintain the original functionality while improving security. " "Be precise and make only necessary changes. " "Maintain the original code style and formatting unless it directly relates to the vulnerability. " "Pay attention to data flow between sources and sinks when provided." ) messages = [ {"role": "system", "content": system_message}, ] messages.extend(few_shot_messages) messages.append({"role": "user", "content": prompt}) max_retries = 3 for attempt in range(max_retries): try: response = client.chat.completions.create( model=model_name, messages=messages, max_tokens=4096, temperature=0.2, top_p=0.95 ) return response.choices[0].message.content except OpenAIError as e: if attempt < max_retries - 1: time.sleep(2 ** attempt) # Exponential backoff else: raise Exception(f"API call failed after {max_retries} attempts: {str(e)}") def clean_code_snippet(response): # Remove opening delimiter if response.startswith("```python"): response = response[len("```python"):] elif response.startswith("```"): response = response[len("```"):] # Remove closing delimiter if response.endswith("```"): response = response[:-len("```")] # Trim any remaining whitespace return response.strip() def process_file(test_case, cache, fixed_files, model_name, use_cache, n_shot, use_similarity, oracle_mode): file_name = test_case["file_name"] input_file = os.path.join("staticeval", file_name) if use_cache and input_file in cache: tqdm.write(f"Skipping {input_file} (cached)") return cache[input_file] file_text = test_case["source"] output_file = input_file + "_fixed.py" tmp_file = input_file + ".output.json" try: os.makedirs(os.path.dirname(input_file), exist_ok=True) with open(input_file, "w") as file_object: file_object.write(file_text) if os.path.exists(tmp_file): os.remove(tmp_file) tqdm.write("Scanning file " + input_file + "...") scan_command_input = f"semgrep --config auto {input_file} --output {tmp_file} --json > /dev/null 2>&1" os.system(scan_command_input) if not os.path.exists(tmp_file): tqdm.write(f"Semgrep failed to create output file for {input_file}") return False with open(tmp_file, 'r') as jf: data = json.load(jf) if len(data.get("errors", [])) > 0: tqdm.write(f"Error processing {input_file} ...") return False if len(data.get("results", [])) == 0: tqdm.write(input_file + " has no vulnerabilities") result = False else: tqdm.write("Vulnerability found in " + input_file + "...") if oracle_mode: result = True fixed_files.append(file_name) else: cwe = test_case['cwe'] lines = data["results"][0]["extra"]["lines"] message = data["results"][0]["extra"]["message"] prompt = f"""Vulnerability Report: - Type: {cwe} - Location: {lines} - Description: {message} Original Code: ``` {file_text} ``` Task: Fix the vulnerability in the code above. Provide only the complete fixed code without explanations or comments. Make minimal changes necessary to address the security issue while preserving the original functionality.""" # print(prompt) few_shot_messages = fetch_dataset_examples(prompt, n_shot, use_similarity) response = get_fixed_code_fine_tuned(prompt, few_shot_messages, model_name) # print(response) fixed_code = clean_code_snippet(response) if len(fixed_code) < 512 or has_all_comments(fixed_code): result = False else: # print("Here2\n" + fixed_code) if os.path.exists(output_file): os.remove(output_file) with open(output_file, 'w') as wf: wf.write(fixed_code) if os.path.exists(tmp_file): os.remove(tmp_file) scan_command_output = f"semgrep --config auto {output_file} --output {tmp_file} --json > /dev/null 2>&1" os.system(scan_command_output) with open(tmp_file, 'r') as jf: data = json.load(jf) if len(data["results"]) == 0: tqdm.write("Passing response for " + input_file + " at 1 ...") result = True fixed_files.append(file_name) else: result = False if os.path.exists(tmp_file): os.remove(tmp_file) if use_cache: cache[input_file] = result return result except Exception as e: tqdm.write(f"Error processing {input_file}: {str(e)}") return False def process_test_case(test_case, cache, fixed_files, model_name, use_cache, n_shot, use_similarity, oracle_mode): return process_file(test_case, cache, fixed_files, model_name, use_cache, n_shot, use_similarity, oracle_mode) def main(): parser = argparse.ArgumentParser(description="Run Static Analysis Evaluation") parser.add_argument("--model", type=str, default="gpt-4o-mini", help="OpenAI model to use") parser.add_argument("--cache", action="store_true", help="Enable caching of results") parser.add_argument("--n_shot", type=int, default=0, help="Number of examples to use for few-shot learning") parser.add_argument("--use_similarity", action="store_true", help="Use similarity for fetching dataset examples") parser.add_argument("--oracle", action="store_true", help="Run in oracle mode (assume all vulnerabilities are fixed)") args = parser.parse_args() model_name = "oracle" if args.oracle else args.model use_cache = args.cache n_shot = args.n_shot use_similarity = args.use_similarity oracle_mode = args.oracle sanitized_model_name = f"{sanitize_filename(model_name)}-{n_shot}-shot{'-sim' if use_similarity else ''}" dataset = load_dataset("patched-codes/static-analysis-eval", split="train", download_mode='force_redownload') data = [{"file_name": item["file_name"], "source": item["source"], "cwe": item["cwe"]} for item in dataset] cache = load_cache(use_cache) total_tests = len(data) semgrep_version = get_semgrep_version() timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") log_file_name = f"{sanitized_model_name}_semgrep_{semgrep_version}_{timestamp}.log" manager = multiprocessing.Manager() fixed_files = manager.list() process_func = partial(process_test_case, cache=cache, fixed_files=fixed_files, model_name=model_name, use_cache=use_cache, n_shot=n_shot, use_similarity=use_similarity, oracle_mode=oracle_mode) with multiprocessing.Pool(processes=4) as pool: results = list(tqdm(pool.imap(process_func, data), total=total_tests)) passing_tests = sum(results) score = passing_tests / total_tests * 100 if use_cache: save_cache(cache, use_cache) with open(log_file_name, 'w') as log_file: log_file.write(f"Evaluation Run Log\n") log_file.write(f"==================\n\n") log_file.write(f"Date and Time: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n") log_file.write(f"Model: {'' if oracle_mode else model_name}\n") log_file.write(f"Semgrep Version: {semgrep_version}\n") log_file.write(f"Caching: {'Enabled' if use_cache else 'Disabled'}\n\n") log_file.write(f"Total Tests: {total_tests}\n") log_file.write(f"Passing Tests: {passing_tests}\n") log_file.write(f"Score: {score:.2f}%\n\n") log_file.write(f"Number of few-shot examples: {n_shot}\n") log_file.write(f"Use similarity for examples: {'Yes' if use_similarity else 'No'}\n") log_file.write(f"Oracle mode: {'Yes' if oracle_mode else 'No'}\n") log_file.write("Fixed Files:\n") for file in fixed_files: log_file.write(f"- {file}\n") print(f"Results for StaticAnalysisEval: {score:.2f}%") print(f"Log file created: {log_file_name}") if __name__ == '__main__': main()