# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install required libraries
pip install requests python-dotenv

# Initialize project
npm init -y

# Install dependencies
npm install axios dotenv

import requests
import os
from dotenv import load_dotenv

# Load environment variables from.env file
load_dotenv()

class BreachDetectionService:
    """
    Service to interface with Breach Intelligence APIs to verify 
    if user credentials have been compromised in recent leaks.
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.haveibeenpwned.com/v3"
        self.headers = {
            " जीबी-api-key": self.api_key,
            "User-Agent": "ICARAX-Security-Audit-Tool"
        }

    def check_email_exposure(self, email: str) -> dict:
        """
        Checks if an email address has been found in known data breaches.
        """
        try:
            # In a production scenario, use the specific provider's endpoint
            response = requests.get(
                f"{self.base_url}/breaches",
                params={"email": email},
                headers=self.headers,
                timeout=10
            )

            # Handle HTTP errors
            if response.status_code == 404:
                return {"is_compromised": False, "breaches": []}
            elif response.status_code == 429:
                return {"error": "Rate limit exceeded. Implement exponential backoff."}
            
            response.raise_for_status()
            
            data = response.json()
            return {
                "is_compromised": len(data) > 0,
                "breaches": [b['Name'] for b in data]
            }

        except requests.exceptions.RequestException as e:
            return {"error": f"Network error: {str(e)}"}

# --- MAIN EXECUTION BLOCK ---
if __name__ == "__main__":
    # Replace with your actual API key
    API_KEY = os.getenv("HIBP_API_KEY")
    
    if not API_KEY:
        print("Error: API Key not found in environment.")
    else:
        service = BreachDetectionService(API_KEY)
        test_email = "user@example.com" # Replace with target email
        
        print(f"Checking integrity for: {test_email}...")
        result = service.check_email_exposure(test_email)
        
        if "error" in result:
            print(f"FAILURE: {result['error']}")
        elif result["is_compromised"]:
            print(f"⚠️ ALERT: Email found in the following breaches: {', '.join(result['breaches'])}")
        else:
            print("✅ SECURE: No known breaches detected for this email.")

import axios from 'axios';
import dotenv from 'dotenv';

dotenv.config();

interface BreachResult {
    isCompromised: boolean;
    breaches: string[];
    error?: string;
}

class BreachDetectionService {
    private apiKey: string;
    private baseUrl: string = 'https://api.haveibeenpwned.com/v3';

    constructor(apiKey: string) {
        this.apiKey = apiKey;
    }

    /**
     * Verifies if an email address appears in recent data leaks.
     * @param email The email address to check.
     */
    async checkEmailExposure(email: string): Promise<BreachResult> {
        try {
            const response = await axios.get(`${this.baseUrl}/breaches`, {
                params: { email },
                headers: {
                    'ीबी-api-key': this.apiKey,
                    'User-Agent': 'ICARAX-Security-Audit-Tool'
                },
                timeout: 10000
            });

            const breaches = response.data.map((b: any) => b.Name);
            
            return {
                isCompromised: breaches.length > 0,
                breaches: breaches
            };
        } catch (error: any) {
            if (error.response?.status === 404) {
                return { isCompromised: false, breaches: [] };
            }
            if (error.response?.status === 429) {
                return { isCompromised: false, breaches: [], error: 'Rate limit exceeded' };
            }
            return { isCompromised: false, breaches: [], error: error.message };
        }
    }
}

// --- IMPLEMENTATION EXAMPLE ---
(async () => {
    const API_KEY = process.env.HIBP_API_KEY;

    if (!API_KEY) {
        console.error("Error: HIBP_API_KEY is missing from environment.");
        process.exit(1);
    }

    const detector = new BreachDetectionService(API_KEY);
    const targetEmail = "user@example.com";

    console.log(`🔍 Scanning: ${targetEmail}`);
    const result = await detector.checkEmailExposure(targetEmail);

    if (result.error) {
        console.error(`❌ Error: ${result.error}`);
    } else if (result.isCompromised) {
        console.warn(`🚨 WARNING: Compromised in: ${result.breaches.join(', ')}`);
    } else {
        console.log("🛡️ Status: Email appears safe.");
    }
})();

# Breach Intelligence API Key (e.g., HaveIBeenPwned)
HIBP_API_KEY=your_secret_api_key_here

# App Settings
NODE_ENV=production
LOG_LEVEL=info

# Logic snippet
if result['is_compromised']:
    user.require_password_reset = True
    user.notify_security_alert("Your email was found in a third-party breach. Please update your password.")
    user.save()