Upload 10 files

Dockerfile

@@ -0,0 +1,37 @@
+# Use Python 3.11 slim image
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY *.py ./
+COPY README.md ./
+
+# Create data directory
+RUN mkdir -p data
+
+# Create non-root user for security
+RUN useradd -m -u 1000 cveuser && chown -R cveuser:cveuser /app
+USER cveuser
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# Default command (can be overridden)
+CMD ["python", "web_ui.py"]

api_client.py

@@ -0,0 +1,27 @@
+import requests
+
+def fetch_cve_simple(cve_id):
+    """Fetch CVE data from NIST NVD API"""
+    url = f"https://services.nvd.nist.gov/rest/json/cves/2.0?cveId={cve_id}"
+    
+    try:
+        response = requests.get(url, timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            if 'vulnerabilities' in data and data['vulnerabilities']:
+                return data['vulnerabilities'][0]
+        return None
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+# Test
+if __name__ == "__main__":
+    cve_data = fetch_cve_simple("CVE-2021-44228")
+    if cve_data:
+        print(" API test successful")
+        cve = cve_data['cve']
+        print(f"CVE ID: {cve['id']}")
+        print(f"Description: {cve['descriptions'][0]['value'][:100]}...")
+    else:
+        print(" API test failed")

app.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""
+HuggingFace Spaces deployment file
+This file is specifically for deploying to HuggingFace Spaces
+"""
+
+import os
+import sys
+
+# Add current directory to path
+sys.path.append('.')
+
+# Import the main web interface
+from web_ui import interface
+
+# Launch the interface
+if __name__ == "__main__":
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        # HuggingFace specific settings
+        enable_queue=True,
+        show_api=False
+    )

cve_validator.py

@@ -0,0 +1,18 @@
+import re
+
+def validate_cve_id(cve_id):
+    """Validate CVE ID format"""
+    pattern = r'^CVE-\d{4}-\d{4,}$'
+    return bool(re.match(pattern, cve_id.upper()))
+
+# Test
+if __name__ == "__main__":
+    test_cases = [
+        "CVE-2021-44228",  # Should pass
+        "CVE-2020-1234",   # Should pass  
+        "invalid",         # Should fail
+    ]
+    
+    for cve in test_cases:
+        result = validate_cve_id(cve)
+        print(f"{cve}: {'✅' if result else '❌'}")

llm_summarizer.py

@@ -0,0 +1,36 @@
+import openai
+import os
+
+def summarize_cve(cve_data):
+    """Generate CVE summary using OpenAI"""
+    api_key = os.getenv('OPENAI_API_KEY')
+    if not api_key:
+        return "OPENAI_API_KEY environment variable required"
+    
+    # Extract basic information
+    cve = cve_data['cve']
+    description = cve['descriptions'][0]['value']
+    
+    # Create prompt in English
+    cve_id = cve['id']
+    prompt = f"Please provide a professional security analysis of this CVE vulnerability in English:\n\nCVE ID: {cve_id}\nDescription: {description}\n\nPlease provide:\n1. Vulnerability Summary\n2. Risk Assessment\n3. Recommended Mitigation Actions\n\nUse British English and security industry terminology."
+    
+    try:
+        client = openai.OpenAI(api_key=api_key)
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=3000
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"LLM error: {e}"
+
+# Test
+if __name__ == "__main__":
+    from api_client import fetch_cve_simple
+    cve_data = fetch_cve_simple("CVE-2021-44228")
+    if cve_data:
+        summary = summarize_cve(cve_data)
+        print("🤖 AI Summary:")
+        print(summary)

main.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+import sys
+import os
+from cve_validator import validate_cve_id
+from api_client import fetch_cve_simple
+from storage import save_cve_analysis, load_cve_analysis
+
+def analyze_cve(cve_id, use_cache=True):
+    """Analyze CVE with caching support"""
+    
+    # Check if already analyzed
+    if use_cache:
+        cached = load_cve_analysis(cve_id)
+        if cached:
+            print(f" Loading from cache: {cve_id}")
+            return cached
+    
+    print(f"🔍 Analyzing {cve_id}...")
+    
+    # Fetch CVE data
+    cve_data = fetch_cve_simple(cve_id)
+    if not cve_data:
+        print(f" Unable to fetch data for {cve_id}")
+        return None
+    
+    # Display basic information
+    cve = cve_data['cve']
+    print(f" {cve['id']}")
+    print(f"Published: {cve['published']}")
+    print(f"Description: {cve['descriptions'][0]['value'][:200]}...")
+    
+    # Get CVSS score
+    if 'metrics' in cve and 'cvssMetricV31' in cve['metrics']:
+        cvss = cve['metrics']['cvssMetricV31'][0]['cvssData']
+        print(f"CVSS Score: {cvss['baseScore']}")
+        print(f"Severity: {cvss['baseSeverity']}")
+    
+    # Try to generate AI summary
+    ai_summary = None
+    if os.getenv('OPENAI_API_KEY'):
+        print("\n Generating AI summary...")
+        try:
+            from llm_summarizer import summarize_cve
+            ai_summary = summarize_cve(cve_data)
+            print(ai_summary)
+        except Exception as e:
+            print(f"AI summary failed: {e}")
+    else:
+        print("\n OPENAI_API_KEY not set, skipping AI summary")
+    
+    # Save analysis results
+    analysis = {
+        'cve_id': cve_id,
+        'cve_data': cve_data,
+        'ai_summary': ai_summary
+    }
+    
+    save_cve_analysis(cve_id, cve_data, ai_summary)
+    
+    return analysis
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage:")
+        print("  python main.py CVE-YYYY-NNNN        # Analyze CVE")
+        print("  python main.py CVE-YYYY-NNNN --force # Force re-analysis")
+        sys.exit(1)
+    
+    cve_id = sys.argv[1]
+    force = '--force' in sys.argv
+    
+    # Validate CVE ID
+    if not validate_cve_id(cve_id):
+        print(f" Invalid CVE ID: {cve_id}")
+        sys.exit(1)
+    
+    # Analyze CVE
+    result = analyze_cve(cve_id, use_cache=not force)
+    
+    if result:
+        print(f"\n Analysis completed: {cve_id}")
+    else:
+        print(f"\n Analysis failed: {cve_id}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+requests>=2.31.0
+openai>=1.3.0
+gradio>=4.44.0
+python-dotenv>=1.0.0

search.py

@@ -0,0 +1,39 @@
+import os
+import json
+
+def search_cves(keyword):
+    """Search analyzed CVEs by keyword"""
+    if not os.path.exists('data'):
+        return []
+    
+    results = []
+    for filename in os.listdir('data'):
+        if filename.endswith('.json'):
+            filepath = os.path.join('data', filename)
+            with open(filepath, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                
+            # Search in description and AI summary
+            cve = data['cve_data']['cve']
+            description = cve['descriptions'][0]['value'].lower()
+            ai_summary = (data.get('ai_summary', '') or '').lower()
+            
+            if keyword.lower() in description or keyword.lower() in ai_summary:
+                results.append({
+                    'cve_id': data['cve_id'],
+                    'analyzed_at': data.get('analyzed_at', ''),
+                    'description': cve['descriptions'][0]['value'][:100] + '...' 
+                })
+    
+    return results
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        keyword = sys.argv[1]
+        results = search_cves(keyword)
+        print(f"🔍 Search results for '{keyword}':")
+        for r in results:
+            print(f"  • {r['cve_id']}: {r['description']}")
+    else:
+        print("Usage: python search.py <keyword>")

storage.py

@@ -0,0 +1,38 @@
+import json
+import os
+from datetime import datetime
+
+def save_cve_analysis(cve_id, cve_data, summary=None):
+    """Save CVE analysis results to JSON file"""
+    if not os.path.exists('data'):
+        os.makedirs('data')
+    
+    analysis = {
+        'cve_id': cve_id,
+        'analyzed_at': datetime.now().isoformat(),
+        'cve_data': cve_data,
+        'ai_summary': summary
+    }
+    
+    filename = f"data/{cve_id}.json"
+    with open(filename, 'w', encoding='utf-8') as f:
+        json.dump(analysis, f, ensure_ascii=False, indent=2)
+    
+    print(f" Saved to {filename}")
+
+def load_cve_analysis(cve_id):
+    """Load analyzed CVE data"""
+    filename = f"data/{cve_id}.json"
+    if os.path.exists(filename):
+        with open(filename, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return None
+
+# Test
+if __name__ == "__main__":
+    from api_client import fetch_cve_simple
+    cve_data = fetch_cve_simple("CVE-2021-44228")
+    if cve_data:
+        save_cve_analysis("CVE-2021-44228", cve_data, "Test summary")
+        loaded = load_cve_analysis("CVE-2021-44228")
+        print(f" Load successful: {loaded['cve_id']}")

web_ui.py

@@ -0,0 +1,274 @@
+import gradio as gr
+import os
+from main import analyze_cve
+from cve_validator import validate_cve_id
+from search import search_cves
+from storage import load_cve_analysis
+
+# Well-known CVE examples for quick testing
+EXAMPLE_CVES = [
+    ("CVE-2021-44228", "Log4Shell - Apache Log4j RCE"),
+    ("CVE-2020-1472", "Zerologon - Windows Netlogon Vulnerability"),
+    ("CVE-2022-22965", "Spring4Shell - Spring Framework RCE"),
+    ("CVE-2021-34527", "PrintNightmare - Windows Print Spooler"),
+    ("CVE-2020-0601", "CurveBall - Windows CryptoAPI Spoofing"),
+]
+
+def analyze_cve_handler(cve_input):
+    """Main CVE analysis function with intelligent caching"""
+    if not cve_input.strip():
+        return "Please enter a CVE ID", ""
+    
+    # Smart input formatting
+    cve_id = cve_input.strip().upper()
+    if not cve_id.startswith('CVE-'):
+        # Auto-add CVE- prefix for formats like "2021-44228"
+        if '-' in cve_id and len(cve_id.split('-')) == 2:
+            cve_id = f"CVE-{cve_id}"
+    
+    # Validate format
+    if not validate_cve_id(cve_id):
+        return f"Invalid CVE format: {cve_id}", ""
+    
+    try:
+        # Check for cached analysis
+        cached = load_cve_analysis(cve_id)
+        
+        if cached:
+            # Load from cache
+            cached_date = cached.get('analyzed_at', 'Unknown date')[:10]
+            source_info = f"**Source:** Local cache ({cached_date})"
+            result = cached
+        else:
+            # First time analysis
+            source_info = "**Source:** NIST API (fresh data)"
+            result = analyze_cve(cve_id, use_cache=False)
+        
+        if result:
+            cve = result['cve_data']['cve']
+            
+            # Format basic information
+            output = f"## {cve['id']}\n\n"
+            output += f"**Published:** {cve['published'][:10]}\n"
+            output += f"**Status:** {cve.get('vulnStatus', 'Unknown')}\n"
+            
+            # CVSS information
+            if 'metrics' in cve and 'cvssMetricV31' in cve['metrics']:
+                cvss = cve['metrics']['cvssMetricV31'][0]['cvssData']
+                output += f"**CVSS Score:** {cvss['baseScore']}/10.0\n"
+                output += f"**Severity:** {cvss['baseSeverity']}\n"
+            
+            # Description - show full description
+            description = cve['descriptions'][0]['value']
+            output += f"\n**Description:**\n{description}"
+            
+            # Add source info at the bottom
+            output += f"\n\n{source_info}"
+            
+            ai_summary = result.get('ai_summary', 'AI summary not available')
+            
+            return output, ai_summary
+        else:
+            return "Failed to fetch CVE data", ""
+    
+    except Exception as e:
+        return "Analysis error occurred", ""
+
+def quick_example_handler(example_choice):
+    """Handle quick example selection"""
+    if example_choice:
+        cve_id = example_choice.split(" - ")[0]
+        return analyze_cve_handler(cve_id)
+    return "Please select an example", ""
+
+def search_handler(keyword):
+    """Search previously analysed CVEs"""
+    if not keyword.strip():
+        return "Please enter search keywords"
+    
+    try:
+        results = search_cves(keyword)
+        if results:
+            output = f"## Found {len(results)} results for '{keyword}'\n\n"
+            
+            for i, r in enumerate(results[:8], 1):
+                output += f"**{i}. {r['cve_id']}**\n"
+                output += f"   {r['description']}\n\n"
+            
+            if len(results) > 8:
+                output += f"... and {len(results) - 8} more results"
+            
+            return output
+        else:
+            return f"No results found for '{keyword}'"
+    except Exception as e:
+        return f"Search failed: {str(e)}"
+
+# Custom CSS for beautiful styling
+custom_css = """
+#main-container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+#title-header {
+    text-align: center;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 30px;
+    border-radius: 15px;
+    margin-bottom: 30px;
+    box-shadow: 0 8px 32px rgba(0,0,0,0.1);
+}
+
+#main-input-card {
+    background: white;
+    padding: 25px;
+    border-radius: 12px;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.08);
+    margin-bottom: 20px;
+    border: 1px solid #e1e8ed;
+}
+
+#results-container {
+    background: white;
+    padding: 20px;
+    border-radius: 12px;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.08);
+    margin: 20px 0;
+    border: 1px solid #e1e8ed;
+}
+
+#analyse-btn {
+    background: linear-gradient(45deg, #667eea, #764ba2);
+    border: none;
+    color: white;
+    font-weight: 500;
+    height: 52px;
+    border-radius: 8px;
+    transition: all 0.3s ease;
+    margin-top: 20px;
+}
+
+#analyse-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+}
+
+.example-btn {
+    height: 52px !important;
+    margin-top: 16px !important;
+}
+
+.quick-examples {
+    background: #f8f9fa;
+    border-radius: 10px;
+    padding: 15px;
+    margin: 15px 0;
+    border: 1px solid #e9ecef;
+}
+
+.search-section {
+    background: #fff;
+    border-radius: 10px;
+    padding: 20px;
+    margin: 15px 0;
+    border: 1px solid #e1e8ed;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+}
+"""
+
+# Main interface with beautiful styling
+with gr.Blocks(css=custom_css, title="CVE Analysis Agent", theme=gr.themes.Soft()) as interface:
+    
+    with gr.Column(elem_id="main-container"):
+        # Beautiful header - ONLY keep main title
+        with gr.Row(elem_id="title-header"):
+            gr.Markdown("""
+            # CVE Analysis Agent
+            """)
+        
+        # Main input card
+        with gr.Column(elem_id="main-input-card"):
+            gr.Markdown("### Enter CVE ID for Analysis")
+            
+            with gr.Row():
+                cve_input = gr.Textbox(
+                    label="CVE Identifier",
+                    placeholder="CVE-2021-44228 or 2021-44228",
+                    info="Smart format detection - accepts both full and short formats",
+                    scale=4,
+                    container=True
+                )
+                analyse_btn = gr.Button(
+                    "Analyse",
+                    variant="primary",
+                    scale=1,
+                    elem_id="analyse-btn"
+                )
+            
+            # Quick examples section
+            with gr.Row(elem_classes="quick-examples"):
+                gr.Markdown("**Quick Examples:**")
+                example_dropdown = gr.Dropdown(
+                    choices=[f"{cve} - {desc}" for cve, desc in EXAMPLE_CVES],
+                    label="Select a famous vulnerability",
+                    value=None,
+                    scale=3
+                )
+                example_btn = gr.Button("Try Example", variant="secondary", scale=1, elem_classes="example-btn")
+        
+        # Results container
+        with gr.Column(elem_id="results-container"):
+            gr.Markdown("### Analysis Results")
+            
+            # CVE Information on top
+            basic_output = gr.Markdown(
+                label="CVE Information",
+                value="*CVE information will appear here after analysis*"
+            )
+            
+            # AI Analysis below
+            ai_output = gr.Markdown(
+                label="AI Security Analysis",
+                value="*AI-generated security analysis will appear here...*"
+            )
+        
+        # Search section
+        with gr.Accordion("Search Previously Analysed CVEs", open=False):
+            with gr.Column(elem_classes="search-section"):
+                gr.Markdown("**Search through your analysed vulnerabilities**")
+                with gr.Row():
+                    search_input = gr.Textbox(
+                        label="Search Keywords",
+                        placeholder="log4j, apache, spring, windows, print",
+                        scale=3
+                    )
+                    search_btn = gr.Button("Search", scale=1)
+                search_output = gr.Markdown(
+                    label="Search Results",
+                    value="*Search results will appear here*"
+                )
+    
+    # Event handlers
+    analyse_btn.click(
+        analyze_cve_handler,
+        inputs=cve_input,
+        outputs=[basic_output, ai_output]
+    )
+    
+    example_btn.click(
+        quick_example_handler,
+        inputs=example_dropdown,
+        outputs=[basic_output, ai_output]
+    )
+    
+    search_btn.click(
+        search_handler,
+        inputs=search_input,
+        outputs=search_output
+    )
+
+if __name__ == "__main__":
+    interface.launch()