_script_for_eval.py

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()