# For more conservative threat models
prompt = f"""
Act as a senior cybersecurity architect with 25+ years of experience 
specializing in {industry_sector} sector threat modeling and penetration 
testing, certified CISSP and OSCP...
"""

# For more comprehensive analysis
"list a mandatory multiple (5) credible threats per category"

# For faster, focused analysis
"list the top 2 most critical threats per category"

# For healthcare applications
prompt += f"""

ADDITIONAL REQUIREMENTS FOR HEALTHCARE:
- Consider HIPAA Privacy Rule and Security Rule requirements
- Assess risks to PHI (Protected Health Information)
- Evaluate BAA (Business Associate Agreement) implications
- Consider patient safety implications of security incidents
"""

{
  "Threat Type": "Spoofing",
  "Scenario": "...",
  "Potential Impact": "...",
  "MITRE ATT&CK Keywords": [...]
}

# Add likelihood and business impact
"""Use JSON with keys: "Threat Type", "Scenario", 
"Potential Impact", "Likelihood" (Low/Medium/High), 
"Business Impact" (Financial/Reputational/Operational), 
"MITRE ATT&CK Keywords"""

# Always use expert-level explanations
"""The audience is security professionals with deep technical 
expertise. Use precise technical terminology and assume knowledge 
of common attack vectors, cryptographic primitives, and network 
protocols."""

# Always use beginner-level explanations
"""The audience is non-technical stakeholders. Avoid jargon, 
explain concepts clearly, and relate threats to business impact."""

cpe:2.3:a:f5:nginx:*:*:*:*:*:*:*:*

cpe:2.3:a:f5:nginx:

TECHNOLOGY_TYPES: dict[str, dict[str, str]] = {
    "Databases": {
        "MySQL": "cpe:2.3:a:mysql:mysql:",
        "MongoDB": "cpe:2.3:a:mongodb:mongodb:",  # New!
        # ... existing entries
    },
    "Web Servers": {  # New category!
        "NGINX": "cpe:2.3:a:f5:nginx:",
        "Apache": "cpe:2.3:a:apache:http_server:",
    },
    # ... existing categories
}

prompt = f"""
Assign a value between 0 and 5 for each factor:
- 0-1: Low
- 2-3: Medium
- 4-5: High
"""

risk_score = (
    damage_potential
    + reproducibility
    + exploitability
    + affected_users
    + discoverability
) / 5  # Changed divisor

prompt = f"""
Use JSON with keys:
- "Threat Type"
- "Scenario" 
- "Damage Potential"
- "Reproducibility"
- "Exploitability"
- "Affected Users"
- "Discoverability"
- "Business Impact": Rate the potential business/financial impact
"""

business_impact = threat.get("Business Impact", 0)
risk_score = (
    damage_potential + reproducibility + exploitability + 
    affected_users + discoverability + business_impact
) / 6  # Now 6 factors

# Emphasize Damage and Exploitability, de-emphasize Discoverability
risk_score = (
    (damage_potential * 2.0) +      # 2x weight
    reproducibility +
    (exploitability * 1.5) +        # 1.5x weight  
    affected_users +
    (discoverability * 0.5)         # 0.5x weight
) / 6.0  # Sum of weights

# Determine risk level
if risk_score >= 8.0:
    risk_level = "🔴 Critical"
elif risk_score >= 6.0:
    risk_level = "🟠 High"
elif risk_score >= 4.0:
    risk_level = "🟡 Medium"
else:
    risk_level = "🟢 Low"

# Add to markdown output
markdown_output += f"| {threat.get('Threat Type')} | ... | {risk_score:.2f} | {risk_level} |\n"

def create_pasta_prompt(app_details, threat_model):
    """Create prompt for PASTA (Process for Attack Simulation 
    and Threat Analysis) assessment."""
    prompt = f"""
    Perform a PASTA threat analysis covering:
    1. Business Objectives
    2. Technical Scope
    3. Application Decomposition  
    4. Threat Analysis
    5. Vulnerability Analysis
    6. Attack Modeling
    7. Risk and Impact Analysis
    
    Application: {app_details}
    Existing threats: {threat_model}
    """
    return prompt

def get_pasta_assessment(api_key, model_name, prompt):
    """Call OpenAI API to generate PASTA assessment."""
    # Similar to get_dread_assessment() implementation
    pass

import streamlit as st
from pasta import create_pasta_prompt, get_pasta_assessment

def render(model_provider, selected_model, openai_api_key):
    st.markdown("## PASTA Threat Analysis")
    
    if st.button("Generate PASTA Assessment"):
        prompt = create_pasta_prompt(
            st.session_state['app_details'],
            st.session_state['threat_model']
        )
        assessment = get_pasta_assessment(
            openai_api_key, selected_model, prompt
        )
        st.markdown(assessment)

from tabs import (
    step1_description,
    # ... existing imports
    step8_pasta,  # New!
)

# In main():
tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8 = st.tabs([
    "Step 1: Description",
    # ... existing tabs
    "Step 8: PASTA Analysis"  # New!
])

# Add render call
render_tab(tab8, step8_pasta.render, 'step8', **model_params)

import requests

def search_misp(misp_url, misp_key, industry_sector):
    """Search MISP for threat events related to industry."""
    headers = {
        "Authorization": misp_key,
        "Accept": "application/json"
    }
    
    payload = {
        "tags": [industry_sector],
        "limit": 10
    }
    
    response = requests.post(
        f"{misp_url}/events/restSearch",
        headers=headers,
        json=payload
    )
    
    return response.json()

def render_api_key_inputs():
    # ... existing code
    
    # Add MISP configuration
    misp_url = st.text_input(
        "MISP URL",
        value=st.session_state.get('misp_url', ''),
        type='default'
    )
    st.session_state['misp_url'] = misp_url
    
    misp_key = st.text_input(
        "MISP API Key", 
        value=st.session_state.get('misp_key', ''),
        type='password'
    )
    st.session_state['misp_key'] = misp_key

# After AlienVault search
misp_url = st.session_state.get('misp_url')
misp_key = st.session_state.get('misp_key')
misp_events = ""

if misp_url and misp_key:
    with st.spinner("Searching MISP for threat intelligence..."):
        try:
            from misp_search import search_misp
            misp_events = search_misp(
                misp_url, 
                misp_key, 
                st.session_state['industry_sector']
            )
        except Exception as e:
            handle_exception(e, "Error fetching MISP data.")

# Add to threat model prompt
threat_model_prompt = create_threat_model_prompt(
    # ... existing parameters
    misp_events=misp_events  # New!
)

def create_threat_model_prompt(
    # ... existing parameters
    misp_events,  # New parameter
):
    prompt = f"""
    # ... existing prompt content
    
    MISP THREAT EVENTS FOR THE INDUSTRY SECTOR:
    {misp_events}
    """
    return prompt

streamlit run main.py

# Add temporary logging
import logging
logger.info(f"Prompt: {prompt}")
logger.info(f"Response: {response}")

import time
start = time.time()
# Your code
elapsed = time.time() - start
logger.info(f"Operation took {elapsed:.2f} seconds")