opsec_requests.py

"""
OPSEC-Enhanced HTTP Request Wrapper
Provides safe, anonymized HTTP requests for OSINT tools
"""

import aiohttp
import logging
from typing import Optional, Dict, Any
from opsec_config import OPSECConfig

# Try to import Tor support, but don't fail if unavailable
try:
    from aiohttp_socks import ProxyConnector
    TOR_AVAILABLE = True
except ImportError:
    TOR_AVAILABLE = False
    ProxyConnector = None

logger = logging.getLogger(__name__)


class OPSECSession:
    """HTTP session with OPSEC protections built-in"""
    
    @staticmethod
    async def get(url: str, **kwargs) -> aiohttp.ClientResponse:
        """
        Make an OPSEC-protected GET request
        
        Args:
            url: Target URL
            **kwargs: Additional aiohttp parameters (will be merged with OPSEC config)
        
        Returns:
            aiohttp.ClientResponse object
        """
        # Apply random delay before request (human-like timing)
        await OPSECConfig.random_delay()
        
        # Get OPSEC configuration
        opsec_config = OPSECConfig.get_request_config()
        
        # Merge with any user-provided kwargs
        headers = opsec_config.get('headers', {})
        if 'headers' in kwargs:
            headers.update(kwargs['headers'])
        
        timeout = aiohttp.ClientTimeout(total=opsec_config.get('timeout', 30))
        
        # Build connector with proxy if Tor is enabled
        connector_kwargs = {}
        if OPSECConfig.USE_TOR:
            # Note: Requires aiohttp-socks for Tor support
            # Will be added in Phase 2
            logger.info(f"Tor routing requested but not yet implemented - using direct connection")
        
        # Create session and make request
        async with aiohttp.ClientSession(
            headers=headers,
            timeout=timeout,
            connector=aiohttp.TCPConnector(**connector_kwargs)
        ) as session:
            logger.debug(f"OPSEC Request: {url}")
            logger.debug(f"User-Agent: {headers.get('User-Agent', 'None')[:50]}...")
            
            async with session.get(url, **kwargs) as response:
                return response
    
    @staticmethod
    async def get_text(url: str, **kwargs) -> str:
        """
        Convenience method: GET request returning text
        
        Args:
            url: Target URL
            **kwargs: Additional aiohttp parameters
        
        Returns:
            Response text as string
        """
        # Apply OPSEC delay
        await OPSECConfig.random_delay()
        
        # Get OPSEC headers
        headers = OPSECConfig.get_request_headers()
        if 'headers' in kwargs:
            headers.update(kwargs['headers'])
        
        timeout = aiohttp.ClientTimeout(total=30)
        
        # Create connector with Tor if enabled
        connector = None
        if OPSECConfig.USE_TOR:
            if not TOR_AVAILABLE:
                logger.warning("Tor requested but aiohttp-socks not available. Using direct connection.")
            else:
                logger.info(f"Routing through Tor: {url}")
                connector = ProxyConnector.from_url('socks5://127.0.0.1:9050')
        
        logger.debug(f"OPSEC GET: {url}")
        
        async with aiohttp.ClientSession(headers=headers, timeout=timeout, connector=connector) as session:
            async with session.get(url, **kwargs) as response:
                return await response.text()
    
    @staticmethod
    async def get_json(url: str, **kwargs) -> Dict:
        """
        Convenience method: GET request returning JSON
        
        Args:
            url: Target URL
            **kwargs: Additional aiohttp parameters
        
        Returns:
            Parsed JSON as dict
        """
        # Apply OPSEC delay
        await OPSECConfig.random_delay()
        
        # Get OPSEC headers
        headers = OPSECConfig.get_request_headers()
        if 'headers' in kwargs:
            headers.update(kwargs['headers'])
        
        timeout = aiohttp.ClientTimeout(total=30)
        
        # Create connector with Tor if enabled
        connector = None
        if OPSECConfig.USE_TOR:
            if not TOR_AVAILABLE:
                logger.warning("Tor requested but aiohttp-socks not available. Using direct connection.")
            else:
                logger.info(f"Routing through Tor (JSON): {url}")
                connector = ProxyConnector.from_url('socks5://127.0.0.1:9050')
        
        logger.debug(f"OPSEC GET JSON: {url}")
        
        async with aiohttp.ClientSession(headers=headers, timeout=timeout, connector=connector) as session:
            async with session.get(url, **kwargs) as response:
                return await response.json()
    
    @staticmethod
    async def post(url: str, data: Optional[Any] = None, **kwargs) -> aiohttp.ClientResponse:
        """
        Make an OPSEC-protected POST request
        
        Args:
            url: Target URL
            data: POST data
            **kwargs: Additional aiohttp parameters
        
        Returns:
            aiohttp.ClientResponse object
        """
        # Apply random delay
        await OPSECConfig.random_delay()
        
        # Get OPSEC headers
        headers = OPSECConfig.get_request_headers()
        if 'headers' in kwargs:
            headers.update(kwargs['headers'])
        
        timeout = aiohttp.ClientTimeout(total=30)
        
        async with aiohttp.ClientSession(headers=headers, timeout=timeout) as session:
            logger.debug(f"OPSEC POST: {url}")
            
            async with session.post(url, data=data, **kwargs) as response:
                return response


# Convenience functions for quick use
async def opsec_get(url: str, **kwargs) -> str:
    """Quick OPSEC-protected GET returning text"""
    return await OPSECSession.get_text(url, **kwargs)


async def opsec_get_json(url: str, **kwargs) -> Dict:
    """Quick OPSEC-protected GET returning JSON"""
    return await OPSECSession.get_json(url, **kwargs)


def log_opsec_status():
    """Log current OPSEC configuration"""
    logger.info("=== OPSEC Status ===")
    logger.info(f"Tor Enabled: {OPSECConfig.USE_TOR}")
    logger.info(f"User-Agent Randomization: {OPSECConfig.RANDOMIZE_USER_AGENT}")
    logger.info(f"Timing Randomization: {OPSECConfig.RANDOMIZE_TIMING}")
    logger.info(f"Average Delay: {OPSECConfig.MEAN_DELAY}s")
    logger.info("===================")