ateam.py

#!/usr/bin/env python3

import sqlite3
import requests
import dns.resolver
import concurrent.futures
import logging
from typing import List, Optional, Dict
from urllib.parse import urlparse
import json
import time
import re
import argparse
import sys
import csv
from datetime import datetime
import urllib3
import os

# Configure logging
logging.basicConfig(
    level=logging.INFO,  # Set root logger to INFO by default
    format='%(asctime)s - %(levelname)s - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)  # Set this specific logger to INFO by default

# Suppress only the single InsecureRequestWarning
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

class AzureTenantFinder:
    def __init__(self, db_path: str = "azure_tenants.db", verbose: bool = False):
        """Initialize the Azure Tenant Finder with SQLite database."""
        self.db_path = db_path
        if verbose:
            logger.setLevel(logging.DEBUG)
        self._init_db()
        
    def _init_db(self):
        """Initialize SQLite database with required tables."""
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS resource_info (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    resource_uri TEXT NOT NULL,
                    resource_type TEXT NOT NULL,
                    tenant_id TEXT,
                    company_display_name TEXT,
                    discovered_at TIMESTAMP DEFAULT (datetime('now', 'localtime')),
                    UNIQUE(resource_uri)
                )
            ''')
            conn.commit()

    # Constants for reuse
    NULL_TENANT_ID = '00000000-0000-0000-0000-000000000000'
    DEVOPS_POTENTIAL_HEADERS = [
        'X-VSS-ResourceTenant',
        'X-TFS-FedAuthIssuer',
        'X-VSS-AuthorizationEndpoint',
        'X-TFS-ServiceError',
        'X-TFS-FedAuthRealm',
        'X-TFS-FedAuthRedirect'
    ]

    def _extract_tenant_from_www_authenticate(self, auth_header: str, key: str = 'authorization_uri', index: int = 3) -> Optional[str]:
        """Extract tenant ID from WWW-Authenticate header."""
        try:
            if f'{key}="' in auth_header:
                auth_uri = auth_header.split(f'{key}="')[1].split('"')[0]
                tenant_id = auth_uri.split('/')[index]
                if tenant_id and tenant_id != self.NULL_TENANT_ID:
                    return tenant_id
            elif f'{key}=' in auth_header:
                auth_uri = auth_header.split(f'{key}=')[1].split(' ')[0]
                tenant_id = auth_uri.split('/')[index]
                if tenant_id and tenant_id != self.NULL_TENANT_ID:
                    return tenant_id
        except Exception as e:
            self._log_exception_details(e, 'extract_tenant_from_www_authenticate')
        return None

    def _extract_tenant_from_oauth_redirect(self, location: str) -> Optional[str]:
        """Extract tenant ID from OAuth redirect URL."""
        try:
            if 'login.microsoftonline.com' in location:
                tenant_id = location.split('login.microsoftonline.com/')[1].split('/')[0]
                if tenant_id and tenant_id != 'common' and len(tenant_id) == 36:
                    return tenant_id
        except Exception as e:
            self._log_exception_details(e, 'extract_tenant_from_oauth_redirect')
        return None

    def _validate_tenant_id(self, tenant_id: str) -> bool:
        return tenant_id and tenant_id != self.NULL_TENANT_ID and tenant_id != 'common'

    def _extract_company_display_name(self, tenant_id: str) -> Optional[str]:
        """Extract company display name from Microsoft's login page for a given tenant ID.
        
        Args:
            tenant_id: The tenant ID to lookup
            
        Returns:
            Optional[str]: The company display name if found, None otherwise
        """
        if not tenant_id or tenant_id == 'common' or tenant_id == self.NULL_TENANT_ID:
            return None
            
        try:
            # Use the same client_id from the sample request
            client_id = "966dc5e4-3e67-44a4-9fa5-7b3959808439"
            url = f"https://login.microsoftonline.com/{tenant_id}/adminconsent?client_id={client_id}&sso_reload=true"
            
            logger.debug(f"Looking up company display name for tenant {tenant_id}")
            
            headers = {
                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
                'Accept-Language': 'en-US,en;q=0.5',
                'Accept-Encoding': 'gzip, deflate, br',
                'Connection': 'keep-alive',
                'Upgrade-Insecure-Requests': '1'
            }
            
            response = requests.get(url, headers=headers, timeout=10, verify=False)
            
            if response.status_code == 200:
                content = response.text
                
                # Look for the sCompanyDisplayName in the response
                import re
                pattern = r'"sCompanyDisplayName"\s*:\s*"([^"]+)"'
                match = re.search(pattern, content)
                
                if match:
                    company_name = match.group(1)
                    # Decode HTML entities
                    import html
                    company_name = html.unescape(company_name)
                    # Handle double-escaped Unicode sequences
                    if '\\u' in company_name:
                        company_name = company_name.encode('utf-8').decode('unicode_escape')
                    logger.debug(f"Found company display name '{company_name}' for tenant {tenant_id}")
                    return company_name
                else:
                    logger.debug(f"No company display name found in response for tenant {tenant_id}")
                    
            else:
                logger.debug(f"HTTP {response.status_code} when looking up company display name for tenant {tenant_id}")
                
        except Exception as e:
            self._log_exception_details(e, f'extract_company_display_name for tenant {tenant_id}')
            
        return None

    def _log_exception_details(self, exception, context: str = None):
        logger.debug(f"Exception in {context if context else ''}: {str(exception)}")
        logger.debug(f"Exception type: {type(exception)}")
        logger.debug(f"Exception args: {exception.args}")
        import traceback
        logger.debug(f"Stack trace: {traceback.format_exc()}")

    def _check_dns(self, lookup: str) -> bool:
        """Check if a DNS record exists for the given lookup string.
        
        Args:
            lookup: The DNS name to check
            
        Returns:
            bool: True if DNS record exists, False otherwise
        """
        logger.debug(f"Checking DNS record: {lookup}")
        try:
            answers = dns.resolver.resolve(lookup, 'A')
            logger.debug(f"DNS record found for {lookup}. IP addresses: {[str(rdata) for rdata in answers]}")
            return True
        except dns.resolver.NXDOMAIN:
            logger.debug(f"No DNS record found for {lookup}")
            return False
        except Exception as e:
            logger.debug(f"DNS resolution error for {lookup}: {str(e)}")
            return False

    def check_app_services(self, resource: str) -> Optional[str]:
        """Check for Azure App Services and extract tenant ID."""
        try:
            lookup = f"{resource}.scm.azurewebsites.net"
            if not self._check_dns(lookup):
                return None

            base_tenant_id = None
            scm_tenant_id = None

            main_url = f"https://{resource}.azurewebsites.net"
            logger.debug(f"Checking main App Service URL: {main_url}")

            try:
                response = requests.get(main_url, allow_redirects=False, timeout=10)
                logger.debug(f"Main App Service response status: {response.status_code}")
                logger.debug(f"Main App Service response headers: {dict(response.headers)}")

                if response.status_code in [301, 302, 307, 308] and 'Location' in response.headers:
                    location = response.headers['Location']
                    logger.debug(f"Found redirect Location header: {location}")
                    tenant_id = self._extract_tenant_from_oauth_redirect(location)
                    if self._validate_tenant_id(tenant_id):
                        self._save_resource(f"{resource}.azurewebsites.net", "AppServices-Base", tenant_id)
                        logger.info(f"Found App Service base URL tenant ID {tenant_id} for {resource} via OAuth flow")
                        base_tenant_id = tenant_id

                if response.status_code == 401 and 'WWW-Authenticate' in response.headers:
                    auth_header = response.headers['WWW-Authenticate']
                    logger.debug(f"Found WWW-Authenticate header: {auth_header}")
                    if 'Bearer' in auth_header:
                        tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization_uri', index=3)
                        if tenant_id and 'login.microsoftonline.com' in auth_header:
                            tenant_id = self._extract_tenant_from_oauth_redirect(auth_header)
                        if self._validate_tenant_id(tenant_id):
                            self._save_resource(f"{resource}.azurewebsites.net", "AppServices-Base", tenant_id)
                            logger.info(f"Found App Service base URL tenant ID {tenant_id} for {resource} via Bearer challenge")
                            base_tenant_id = tenant_id

            except requests.exceptions.RequestException as e:
                logger.debug(f"Main App Service request error: {str(e)}")
                if hasattr(e, 'response') and e.response is not None:
                    logger.debug(f"Error response status: {e.response.status_code}")
                    logger.debug(f"Error response headers: {dict(e.response.headers)}")
                    if 'Location' in e.response.headers:
                        location = e.response.headers['Location']
                        tenant_id = self._extract_tenant_from_oauth_redirect(location)
                        if self._validate_tenant_id(tenant_id):
                            self._save_resource(f"{resource}.azurewebsites.net", "AppServices-Base", tenant_id)
                            logger.info(f"Found App Service base URL tenant ID {tenant_id} for {resource} via OAuth error redirect")
                            base_tenant_id = tenant_id

            url = f"https://{resource}.scm.azurewebsites.net/"
            logger.debug(f"Checking App Service SCM URL: {url}")

            try:
                response = requests.head(url, allow_redirects=False, timeout=10)
                logger.debug(f"App Service SCM response status: {response.status_code}")
                logger.debug(f"App Service SCM response headers: {dict(response.headers)}")

                if 'Location' in response.headers:
                    location = response.headers['Location']
                    logger.debug(f"Found Location header: {location}")
                    try:
                        tenant_id = location.split('/')[3]
                        logger.debug(f"Extracted potential tenant ID from Location header: {tenant_id}")
                        if tenant_id and (tenant_id == 'common' or (len(tenant_id) == 36 and tenant_id != self.NULL_TENANT_ID)):
                            self._save_resource(f"{resource}.scm.azurewebsites.net", "AppServices-SCM", tenant_id)
                            logger.info(f"Found App Services SCM tenant ID {tenant_id} for {resource}")
                            scm_tenant_id = tenant_id
                    except (IndexError, AttributeError) as e:
                        self._log_exception_details(e, 'extract_tenant_id_from_location_header')

                if response.status_code == 401 and 'WWW-Authenticate' in response.headers:
                    auth_header = response.headers['WWW-Authenticate']
                    logger.debug(f"Found WWW-Authenticate header: {auth_header}")
                    if auth_header.startswith('Basic'):
                        logger.debug("Basic authentication challenge detected - this is an App Service")
                        self._save_resource(f"{resource}.scm.azurewebsites.net", "AppServices-SCM", "common")
                        logger.info(f"Found App Service SCM tenant ID 'common' for {resource}")
                        if not scm_tenant_id:
                            scm_tenant_id = "common"

            except requests.exceptions.RequestException as e:
                logger.debug(f"App Service SCM request error for {url}: {str(e)}")
                if hasattr(e, 'response') and e.response is not None:
                    logger.debug(f"Error response status: {e.response.status_code}")
                    logger.debug(f"Error response headers: {dict(e.response.headers)}")
                    if 'Location' in e.response.headers:
                        location = e.response.headers['Location']
                        logger.debug(f"Found Location header in error response: {location}")
                        try:
                            tenant_id = location.split('/')[3]
                            logger.debug(f"Extracted potential tenant ID from error response Location header: {tenant_id}")
                            if tenant_id and (tenant_id == 'common' or (len(tenant_id) == 36 and tenant_id != self.NULL_TENANT_ID)):
                                self._save_resource(f"{resource}.scm.azurewebsites.net", "AppServices-SCM", tenant_id)
                                logger.info(f"Found App Services SCM tenant ID {tenant_id} for {resource}")
                                scm_tenant_id = tenant_id
                        except (IndexError, AttributeError) as e:
                            self._log_exception_details(e, 'extract_tenant_id_from_error_location_header')
                    if e.response.status_code == 401 and 'WWW-Authenticate' in e.response.headers:
                        auth_header = e.response.headers['WWW-Authenticate']
                        logger.debug(f"Found WWW-Authenticate header in error response: {auth_header}")
                        if auth_header.startswith('Basic'):
                            logger.debug("Basic authentication challenge detected in error response - this is an App Service")
                            self._save_resource(f"{resource}.scm.azurewebsites.net", "AppServices-SCM", "common")
                            logger.info(f"Found App Service SCM tenant ID 'common' for {resource}")
                            if not scm_tenant_id:
                                scm_tenant_id = "common"

        except Exception as e:
            self._log_exception_details(e, 'check_app_services')

        if base_tenant_id and base_tenant_id != 'common':
            return base_tenant_id
        elif scm_tenant_id and scm_tenant_id != 'common':
            return scm_tenant_id
        elif base_tenant_id:
            return base_tenant_id
        else:
            return scm_tenant_id

    def check_devops(self, resource: str) -> Optional[str]:
        """Check for Azure DevOps and extract tenant ID."""
        try:
            url = f"https://dev.azure.com/{resource}/_apis/Contribution/HierarchyQuery"
            logger.debug(f"Checking DevOps URL: {url}")

            headers = {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'X-TFS-FedAuthRedirect': 'Suppress',
                'X-TFS-Session': resource
            }
            data = {
                "contributionIds": ["ms.vss-features.my-organizations-data-provider"],
                "dataProviderContext": {"properties": {}}
            }
            response = requests.post(url, headers=headers, json=data, timeout=10, verify=False)
            logger.debug(f"Initial response status: {response.status_code}")
            logger.debug(f"Response headers: {dict(response.headers)}")

            for header in self.DEVOPS_POTENTIAL_HEADERS:
                if header in response.headers:
                    value = response.headers[header]
                    logger.debug(f"Found header {header}: {value}")
                    if header == 'X-VSS-ResourceTenant' and value != self.NULL_TENANT_ID:
                        tenant_id = value
                        self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                        logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                        return tenant_id
                    elif 'microsoftonline.com' in value:
                        tenant_id = value.split('/')[-1]
                        if tenant_id and tenant_id != 'dev.azure.com':
                            self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                            logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                            return tenant_id
                    elif header == 'X-TFS-FedAuthRedirect' and 'microsoftonline.com' in value:
                        try:
                            from urllib.parse import urlparse, parse_qs
                            parsed = urlparse(value)
                            params = parse_qs(parsed.fragment.split('#')[0])
                            if 'ctx' in params:
                                ctx = params['ctx'][0]
                                if 'microsoftonline.com' in ctx:
                                    tenant_id = ctx.split('microsoftonline.com/')[1].split('"')[0]
                                    if tenant_id and tenant_id != 'dev.azure.com':
                                        self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                                        logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                                        return tenant_id
                        except Exception as e:
                            self._log_exception_details(e, 'devops_redirect_url_parse')

            if response.status_code in [401, 403]:
                auth_header = response.headers.get('WWW-Authenticate', '')
                logger.debug(f"WWW-Authenticate header: {auth_header}")
                if 'Bearer' in auth_header:
                    tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization_uri', index=-1)
                    if tenant_id and tenant_id != 'dev.azure.com':
                        self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                        logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                        return tenant_id

            url = f"https://{resource}.vssps.visualstudio.com/_apis/Token/SessionToken"
            logger.debug(f"Checking VSSPS URL: {url}")
            response = requests.get(url, headers=headers, timeout=10, verify=False)
            logger.debug(f"VSSPS response status: {response.status_code}")
            logger.debug(f"VSSPS response headers: {dict(response.headers)}")
            for header in self.DEVOPS_POTENTIAL_HEADERS:
                if header in response.headers:
                    value = response.headers[header]
                    logger.debug(f"Found header {header}: {value}")
                    if header == 'X-VSS-ResourceTenant' and value != self.NULL_TENANT_ID:
                        tenant_id = value
                        self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                        logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                        return tenant_id
                    elif 'microsoftonline.com' in value:
                        tenant_id = value.split('/')[-1]
                        if tenant_id and tenant_id != 'dev.azure.com':
                            self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                            logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                            return tenant_id
        except requests.exceptions.RequestException as e:
            logger.debug(f"DevOps request failed for {resource}: {str(e)}")
            if hasattr(e, 'response') and e.response is not None and hasattr(e.response, 'headers'):
                headers = e.response.headers
                logger.debug(f"Response headers: {dict(headers)}")
                for header in self.DEVOPS_POTENTIAL_HEADERS:
                    if header in headers:
                        value = headers[header]
                        logger.debug(f"Found header {header}: {value}")
                        if header == 'X-VSS-ResourceTenant' and value != self.NULL_TENANT_ID:
                            tenant_id = value
                            self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                            logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                            return tenant_id
                        elif 'microsoftonline.com' in value:
                            tenant_id = value.split('/')[-1]
                            if tenant_id and tenant_id != 'dev.azure.com':
                                self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                                logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                                return tenant_id
                auth_header = headers.get('WWW-Authenticate', '')
                logger.debug(f"WWW-Authenticate header: {auth_header}")
                if 'Bearer' in auth_header:
                    tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization_uri', index=-1)
                    if tenant_id and tenant_id != 'dev.azure.com':
                        self._save_resource(f"dev.azure.com/{resource}", "DevOps", tenant_id)
                        logger.info(f"Found DevOps tenant ID {tenant_id} for {resource}")
                        return tenant_id
        except Exception as e:
            self._log_exception_details(e, 'check_devops')
        return None

    def check_sharepoint(self, resource: str) -> Optional[str]:
        """Check for SharePoint Online and extract tenant ID."""
        try:
            lookup = f"{resource}.sharepoint.com"
            if not self._check_dns(lookup):
                return None

            url = f"https://{resource}.sharepoint.com/_vti_bin/client.svc"
            headers = {
                'Authorization': 'Bearer',
                'Accept': 'application/json'
            }
            try:
                response = requests.get(url, headers=headers, timeout=10)
                if 'WWW-Authenticate' in response.headers:
                    auth_header = response.headers['WWW-Authenticate']
                    if 'Bearer realm="' in auth_header:
                        try:
                            tenant_id = auth_header.split('Bearer realm="')[1].split('"')[0]
                            if self._validate_tenant_id(tenant_id):
                                self._save_resource(f"{resource}.sharepoint.com", "SharePoint", tenant_id)
                                logger.info(f"Found SharePoint tenant ID {tenant_id} for {resource}")
                                return tenant_id
                        except Exception as e:
                            self._log_exception_details(e, 'sharepoint_bearer_realm_parse')
            except Exception as e:
                self._log_exception_details(e, 'sharepoint_client_svc')

            url = f"https://{resource}.sharepoint.com/_forms/default.aspx"
            try:
                response = requests.get(url, timeout=10)
                logger.debug(f"Response headers for {resource}: {dict(response.headers)}")
                if 'X-MS-CobaltId' in response.headers:
                    tenant_id = response.headers['X-MS-CobaltId']
                    if self._validate_tenant_id(tenant_id):
                        self._save_resource(f"{resource}.sharepoint.com", "SharePoint", tenant_id)
                        logger.info(f"Found SharePoint tenant ID {tenant_id} for {resource}")
                        return tenant_id
            except Exception as e:
                self._log_exception_details(e, 'sharepoint_default_aspx')
        except Exception as e:
            self._log_exception_details(e, 'check_sharepoint')
        return None

    def check_key_vault(self, resource: str) -> Optional[str]:
        """Check for Azure Key Vault and extract tenant ID."""
        try:
            lookup = f"{resource}.vault.azure.net"
            if not self._check_dns(lookup):
                return None

            url = f"https://{resource}.vault.azure.net/keys"
            logger.debug(f"Checking Key Vault URL: {url}")
            try:
                response = requests.head(url, headers={"x-ms-version": "2019-12-12"}, timeout=5, verify=False)
                logger.debug(f"Key Vault response status: {response.status_code}")
                logger.debug(f"Key Vault response headers: {dict(response.headers)}")
                if 'WWW-Authenticate' in response.headers:
                    auth_header = response.headers['WWW-Authenticate']
                    tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization', index=-1)
                    if self._validate_tenant_id(tenant_id):
                        self._save_resource(f"{resource}.vault.azure.net", "KeyVault", tenant_id)
                        logger.info(f"Found Key Vault tenant ID {tenant_id} for {resource}")
                        return tenant_id
            except requests.exceptions.RequestException as e:
                if hasattr(e, 'response') and e.response is not None:
                    logger.debug(f"Key Vault error response status: {e.response.status_code}")
                    logger.debug(f"Key Vault error response headers: {dict(e.response.headers)}")
                    if 'WWW-Authenticate' in e.response.headers:
                        auth_header = e.response.headers['WWW-Authenticate']
                        tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization', index=-1)
                        if self._validate_tenant_id(tenant_id):
                            self._save_resource(f"{resource}.vault.azure.net", "KeyVault", tenant_id)
                            logger.info(f"Found Key Vault tenant ID {tenant_id} for {resource}")
                            return tenant_id
                else:
                    self._log_exception_details(e, 'key_vault_request')
        except Exception as e:
            self._log_exception_details(e, 'check_key_vault')
        return None

    def check_storage_account(self, resource: str) -> Optional[str]:
        """Check for Azure Storage Account and extract tenant ID."""
        logger.debug(f"Entering check_storage_account for {resource}")
        try:
            lookup = f"{resource}.blob.core.windows.net"
            if not self._check_dns(lookup):
                return None

            url = f"https://{resource}.blob.core.windows.net/?comp=blobs"
            logger.debug(f"Checking Storage Account URL: {url}")
            
            try:
                response = requests.get(url, headers={"x-ms-version": "2019-12-12"}, timeout=5, verify=False)
                logger.debug(f"Storage Account response status: {response.status_code}")
                logger.debug(f"Storage Account response headers: {dict(response.headers)}")
                
                if response.status_code == 401 and 'WWW-Authenticate' in response.headers:
                    auth_header = response.headers['WWW-Authenticate']
                    tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization_uri', index=3)
                    if self._validate_tenant_id(tenant_id):
                        self._save_resource(f"{resource}.blob.core.windows.net", "StorageAccount", tenant_id)
                        logger.info(f"Found Storage Account tenant ID {tenant_id} for {resource}")
                        return tenant_id
                        
            except requests.exceptions.RequestException as e:
                if hasattr(e, 'response') and e.response is not None:
                    logger.debug(f"Storage Account error response status: {e.response.status_code}")
                    logger.debug(f"Storage Account error response headers: {dict(e.response.headers)}")
                    
                    if 'WWW-Authenticate' in e.response.headers:
                        auth_header = e.response.headers['WWW-Authenticate']
                        tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization_uri', index=3)
                        if self._validate_tenant_id(tenant_id):
                            self._save_resource(f"{resource}.blob.core.windows.net", "StorageAccount", tenant_id)
                            logger.info(f"Found Storage Account tenant ID {tenant_id} for {resource}")
                            return tenant_id
                    else:
                        # Try alternate endpoint
                        url = f"https://{resource}.blob.core.windows.net/?restype=service&comp=properties"
                        logger.debug(f"Checking alternate Storage Account URL: {url}")
                        
                        try:
                            response = requests.get(url, headers={"x-ms-version": "2019-12-12"}, timeout=5, verify=False)
                            logger.debug(f"Storage Account response status: {response.status_code}")
                            logger.debug(f"Storage Account response headers: {dict(response.headers)}")
                            
                            if response.status_code == 401 and 'WWW-Authenticate' in response.headers:
                                auth_header = response.headers['WWW-Authenticate']
                                tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization_uri', index=3)
                                if self._validate_tenant_id(tenant_id):
                                    self._save_resource(f"{resource}.blob.core.windows.net", "StorageAccount", tenant_id)
                                    logger.info(f"Found Storage Account tenant ID {tenant_id} for {resource}")
                                    return tenant_id
                                    
                        except requests.exceptions.RequestException as e2:
                            if hasattr(e2, 'response') and e2.response is not None and 'WWW-Authenticate' in e2.response.headers:
                                auth_header = e2.response.headers['WWW-Authenticate']
                                tenant_id = self._extract_tenant_from_www_authenticate(auth_header, key='authorization_uri', index=3)
                                if self._validate_tenant_id(tenant_id):
                                    self._save_resource(f"{resource}.blob.core.windows.net", "StorageAccount", tenant_id)
                                    logger.info(f"Found Storage Account tenant ID {tenant_id} for {resource}")
                                    return tenant_id
                else:
                    self._log_exception_details(e, 'storage_account_request')
                    
        except Exception as e:
            self._log_exception_details(e, 'check_storage_account')
        return None

    def check_databricks(self, resource: str) -> Optional[str]:
        """Check for Azure Databricks and extract tenant ID."""
        try:
            lookup = f"{resource}.azuredatabricks.net"
            if not self._check_dns(lookup):
                return None

            url = f"https://{resource}.azuredatabricks.net/aad/auth?hash="
            logger.debug(f"Checking Databricks URL: {url}")
            try:
                response = requests.get(url, allow_redirects=False, timeout=10)
                logger.debug(f"Databricks response status: {response.status_code}")
                logger.debug(f"Databricks response headers: {dict(response.headers)}")
                if 'Location' in response.headers:
                    location = response.headers['Location']
                    try:
                        tenant_id = location.split('/')[3]
                        if self._validate_tenant_id(tenant_id):
                            self._save_resource(f"{resource}.azuredatabricks.net", "Databricks", tenant_id)
                            logger.info(f"Found Databricks tenant ID {tenant_id} for {resource}")
                            return tenant_id
                    except Exception as e:
                        self._log_exception_details(e, 'databricks_location_parse')
            except requests.exceptions.RequestException as e:
                if hasattr(e, 'response') and e.response is not None:
                    logger.debug(f"Error response status: {e.response.status_code}")
                    logger.debug(f"Error response headers: {dict(e.response.headers)}")
                    if 'Location' in e.response.headers:
                        location = e.response.headers['Location']
                        try:
                            tenant_id = location.split('/')[3]
                            if self._validate_tenant_id(tenant_id):
                                self._save_resource(f"{resource}.azuredatabricks.net", "Databricks", tenant_id)
                                logger.info(f"Found Databricks tenant ID {tenant_id} for {resource}")
                                return tenant_id
                        except Exception as e:
                            self._log_exception_details(e, 'databricks_error_location_parse')
                else:
                    self._log_exception_details(e, 'databricks_request')
        except Exception as e:
            self._log_exception_details(e, 'check_databricks')
        return None

    def _save_resource(self, resource_uri: str, resource_type: str, tenant_id: str):
        """Save discovered resource to database."""
        # Extract company display name if tenant_id is valid and not 'common'
        company_display_name = None
        if tenant_id and tenant_id != 'common' and tenant_id != self.NULL_TENANT_ID:
            company_display_name = self._extract_company_display_name(tenant_id)
        
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute('''
                INSERT INTO resource_info (resource_uri, resource_type, tenant_id, company_display_name, discovered_at)
                VALUES (?, ?, ?, ?, ?)
                ON CONFLICT(resource_uri) DO UPDATE SET
                    tenant_id = excluded.tenant_id,
                    company_display_name = excluded.company_display_name,
                    discovered_at = ?
            ''', (resource_uri, resource_type, tenant_id, company_display_name, 
                  datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                  datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
            conn.commit()

    def generate_permutations(self, resources: List[str], permutations_file: str = None) -> List[str]:
        """Generate permutations of resource names using a permutations file.
        
        Args:
            resources: List of base resource names
            permutations_file: Path to the permutations file (default: None, will use permutations.txt in script directory)
            
        Returns:
            List[str]: List of resource names with permutations
        """
        # Determine the permutations file path
        if not permutations_file or permutations_file == 'default':
            permutations_path = os.path.join(os.path.dirname(__file__), "permutations.txt")
        else:
            permutations_path = permutations_file
            
        if not os.path.exists(permutations_path):
            logger.warning(f"Permutations file not found at {permutations_path}. Skipping permutations.")
            return resources
        
        try:
            with open(permutations_path, 'r') as f:
                permutations = [p.strip() for p in f if p.strip()]
                # Remove duplicates while preserving order
                permutations = list(dict.fromkeys(permutations))
                
            logger.info(f"Loaded {len(permutations)} permutations from {permutations_path}")
            
            generated = []
            for resource in resources:
                # Add the original resource
                generated.append(resource)
                
                # Generate prepend permutations (permutation + resource)
                for perm in permutations:
                    generated.append(f"{perm}{resource}")
                    generated.append(f"{perm}-{resource}")
                    
                # Generate append permutations (resource + permutation)
                for perm in permutations:
                    generated.append(f"{resource}{perm}")
                    generated.append(f"{resource}-{perm}")
            
            # Remove any duplicates
            unique_resources = list(dict.fromkeys(generated))
            logger.info(f"Generated {len(unique_resources)} permutations from {len(resources)} base resources")
            return unique_resources
            
        except Exception as e:
            logger.error(f"Error generating permutations: {str(e)}")
            return resources

    def process_resources(self, resources: List[str], max_workers: int = 10, use_permutations: str = None, batch_size: int = 1000):
        """Process multiple resources concurrently using ThreadPoolExecutor.
        
        Args:
            resources: List of resource names to process
            max_workers: Maximum number of concurrent threads (default: 10)
            use_permutations: Path to permutations file or 'default' to use permutations.txt (default: None)
            batch_size: Number of resources to process in each batch (default: 1000)
        """
        logger.debug(f"Processing {len(resources)} resources with {max_workers} workers")
        
        # Generate permutations if requested
        if use_permutations:
            logger.info(f"Generating permutations of resource names...")
            resources = self.generate_permutations(resources, use_permutations)
            logger.info(f"Generated {len(resources)} total resources to process")
        
        # Process resources in batches to prevent memory issues
        total_resources = len(resources)
        processed_count = 0
        
        for i in range(0, total_resources, batch_size):
            batch = resources[i:i + batch_size]
            batch_num = (i // batch_size) + 1
            total_batches = (total_resources + batch_size - 1) // batch_size
            
            logger.info(f"Processing batch {batch_num}/{total_batches} ({len(batch)} resources, {processed_count}/{total_resources} total processed)")
            
            with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
                # Submit batch tasks
                future_to_resource = {
                    executor.submit(self.process_resource, resource): resource 
                    for resource in batch
                }
                
                # Process completed tasks in this batch
                batch_processed = 0
                for future in concurrent.futures.as_completed(future_to_resource):
                    resource = future_to_resource[future]
                    try:
                        future.result()
                        processed_count += 1
                        batch_processed += 1
                        
                        # Show progress every 50 resources or at the end of batch
                        if batch_processed % 50 == 0 or batch_processed == len(batch):
                            logger.info(f"Batch {batch_num}: {batch_processed}/{len(batch)} completed ({processed_count}/{total_resources} total)")
                            
                    except Exception as e:
                        logger.error(f"Error processing resource {resource}: {str(e)}")
                        logger.debug(f"Exception type: {type(e)}")
                        logger.debug(f"Exception args: {e.args}")
                        import traceback
                        logger.debug(f"Stack trace: {traceback.format_exc()}")
                        processed_count += 1
                        batch_processed += 1
            
            # Small delay between batches to prevent overwhelming the system
            if i + batch_size < total_resources:
                time.sleep(1)
        
        logger.info(f"Completed processing all {total_resources} resources")

    def process_resource(self, resource: str):
        """Process a single resource name."""
        logger.info(f"Processing resource: {resource}")
        
        # Skip if resource name is too short
        if len(resource) < 2:
            logger.debug(f"Skipping resource '{resource}' - too short (minimum 2 characters)")
            return
            
        # Check services that work with 2+ characters
        logger.debug("Checking App Services...")
        self.check_app_services(resource)
        
        logger.debug("Checking DevOps...")
        self.check_devops(resource)
        
        logger.debug("Checking SharePoint...")
        self.check_sharepoint(resource)
        
        # Check services that require 3+ characters
        if len(resource) >= 3:
            logger.debug("Starting Storage Account check...")
            try:
                result = self.check_storage_account(resource)
                logger.debug(f"Storage Account check completed. Result: {result}")
            except Exception as e:
                logger.debug(f"Error during Storage Account check: {str(e)}")
                logger.debug(f"Exception type: {type(e)}")
                logger.debug(f"Exception args: {e.args}")
                import traceback
                logger.debug(f"Stack trace: {traceback.format_exc()}")
            
            logger.debug("Checking Key Vault...")
            self.check_key_vault(resource)
            
            logger.debug("Checking Databricks...")
            self.check_databricks(resource)
        else:
            logger.debug(f"Skipping Key Vault, Storage Account, and Databricks checks - resource name '{resource}' is too short (minimum 3 characters)")

    def export_results(self, format: str, tenant_id: Optional[str] = None, run_timestamp: Optional[datetime] = None):
        """Export results to specified format (csv, json, html).
        
        Args:
            format: Export format ('csv', 'json', or 'html')
            tenant_id: If provided, only export resources with this tenant ID
            run_timestamp: If provided, only export resources discovered after this timestamp
        """
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            query = '''
                SELECT resource_uri, resource_type, tenant_id, company_display_name, discovered_at 
                FROM resource_info 
                WHERE 1=1
            '''
            params = []
            
            if tenant_id:
                query += ' AND tenant_id = ?'
                params.append(tenant_id)
            
            if run_timestamp:
                query += ' AND datetime(discovered_at) > datetime(?)'
                params.append(run_timestamp.strftime('%Y-%m-%d %H:%M:%S'))
                
            query += ' ORDER BY resource_type, resource_uri'
            
            cursor.execute(query, params)
            results = cursor.fetchall()
            
            if not results:
                print("\nNo resources to export matching the criteria.")
                return
            
            # Always generate a filename with timestamp
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            output_file = f"azure_tenants_export_{timestamp}.{format}"
            
            try:
                if format.lower() == 'csv':
                    self._export_csv(results, output_file)
                elif format.lower() == 'json':
                    self._export_json(results, output_file)
                elif format.lower() == 'html':
                    self._export_html(results, output_file)
                else:
                    print(f"Unsupported export format: {format}")
                    return
                
                print(f"\nResults exported to: {output_file}")
                
            except Exception as e:
                print(f"Error exporting results: {str(e)}")

    def _export_csv(self, results: List[tuple], output_file: str):
        """Export results to CSV format."""
        with open(output_file, 'w', newline='', encoding='utf-8') as f:
            writer = csv.writer(f)
            writer.writerow(['Resource URI', 'Type', 'Tenant ID', 'Company Display Name', 'Discovered At'])
            writer.writerows(results)

    def _export_json(self, results: List[tuple], output_file: str):
        """Export results to JSON format."""
        data = []
        for row in results:
            # Decode HTML entities in company display name if present
            company_name = row[3] or ""
            if company_name:
                # Handle double-escaped Unicode sequences first
                if '\\u' in company_name:
                    company_name = company_name.encode('utf-8').decode('unicode_escape')
                # Then decode HTML entities
                import html
                company_name = html.unescape(company_name)
            
            data.append({
                'resource_uri': row[0],
                'resource_type': row[1],
                'tenant_id': row[2],
                'company_display_name': company_name,
                'discovered_at': row[4]
            })
        
        with open(output_file, 'w') as f:
            json.dump(data, f, indent=2)

    def _export_html(self, results: List[tuple], output_file: str):
        """Export results to HTML format with styled table."""
        css = (
            'body{background-color:#07142A;color:#F3F1E6;margin:0;padding:20px;font-family:Arial,sans-serif}'
            '.container{max-width:1200px;margin:0 auto}'
            '.header{display:flex;align-items:center;justify-content:center;margin-bottom:30px;gap:20px}'
            '.logo{height:60px;width:auto;border-radius:8px}'
            'h1{color:#F56A00;text-align:center;margin:0}'
            '.timestamp{color:#71808D;text-align:center;margin-bottom:30px;font-size:0.9em}'
            '.search-container{margin-bottom:20px;text-align:center}'
            '.search-input{padding:8px 12px;width:300px;border:none;border-radius:4px;background-color:#345367;color:#F3F1E6;font-family:Arial,sans-serif}'
            '.search-input::placeholder{color:#71808D}'
            '.search-input:focus{outline:none;box-shadow:0 0 0 2px #F56A00}'
            'table{width:100%;border-collapse:collapse;background-color:#345367;border-radius:8px;overflow:hidden;box-shadow:0 4px 6px rgba(0,0,0,0.1)}'
            'th{background-color:#F3F1E6;color:#07142A;padding:12px;text-align:left;font-weight:bold;cursor:pointer;user-select:none}'
            'th:hover{background-color:#F56A00;color:#F3F1E6}'
            'th::after{content:"";display:inline-block;width:0;height:0;margin-left:5px;vertical-align:middle;border-left:4px solid transparent;border-right:4px solid transparent}'
            'th.asc::after{border-bottom:4px solid #07142A}'
            'th.desc::after{border-top:4px solid #07142A}'
            'td{padding:12px;border-bottom:1px solid #71808D}'
            'tr:last-child td{border-bottom:none}'
            'tr:hover{background-color:#2A4252}'
            '.resource-type{color:#F56A00;font-weight:bold}'
            '.tenant-id{color:#F3F1E6}'
            '.company-name{color:#F56A00;font-weight:bold}'
            '.no-results{text-align:center;padding:20px;color:#71808D;display:none}'
            '@media (max-width:768px){.header{flex-direction:column;gap:10px}.logo{height:40px}table{display:block;overflow-x:auto}}'
        )
        
        js = '''
            function sortTable(n) {
                var table, rows, switching, i, x, y, shouldSwitch, dir, switchcount = 0;
                table = document.querySelector("table");
                switching = true;
                dir = "asc";
                
                // Remove sort indicators from all headers
                table.querySelectorAll("th").forEach(th => {
                    th.classList.remove("asc", "desc");
                });
                
                while (switching) {
                    switching = false;
                    rows = table.rows;
                    
                    for (i = 1; i < (rows.length - 1); i++) {
                        shouldSwitch = false;
                        x = rows[i].getElementsByTagName("td")[n];
                        y = rows[i + 1].getElementsByTagName("td")[n];
                        
                        if (dir == "asc") {
                            if (x.innerHTML.toLowerCase() > y.innerHTML.toLowerCase()) {
                                shouldSwitch = true;
                                break;
                            }
                        } else if (dir == "desc") {
                            if (x.innerHTML.toLowerCase() < y.innerHTML.toLowerCase()) {
                                shouldSwitch = true;
                                break;
                            }
                        }
                    }
                    
                    if (shouldSwitch) {
                        rows[i].parentNode.insertBefore(rows[i + 1], rows[i]);
                        switching = true;
                        switchcount++;
                    } else {
                        if (switchcount == 0 && dir == "asc") {
                            dir = "desc";
                            switching = true;
                        }
                    }
                }
                
                // Add sort indicator to current header
                table.getElementsByTagName("th")[n].classList.add(dir);
            }
            
            function filterTable() {
                var input = document.getElementById("searchInput");
                var filter = input.value.toLowerCase();
                var table = document.querySelector("table");
                var tr = table.getElementsByTagName("tr");
                var noResults = document.getElementById("noResults");
                var hasResults = false;
                
                for (var i = 1; i < tr.length; i++) {
                    var td = tr[i].getElementsByTagName("td");
                    var found = false;
                    
                    for (var j = 0; j < td.length; j++) {
                        if (td[j].innerHTML.toLowerCase().indexOf(filter) > -1) {
                            found = true;
                            break;
                        }
                    }
                    
                    if (found) {
                        tr[i].style.display = "";
                        hasResults = true;
                    } else {
                        tr[i].style.display = "none";
                    }
                }
                
                noResults.style.display = hasResults ? "none" : "block";
            }
            
            // Add event listeners when the page loads
            document.addEventListener("DOMContentLoaded", function() {
                // Add click handlers to all headers
                document.querySelectorAll("th").forEach((th, index) => {
                    th.addEventListener("click", () => sortTable(index));
                });
                
                // Add input handler for search
                document.getElementById("searchInput").addEventListener("input", filterTable);
            });
        '''

        html_template = (
            '<!DOCTYPE html>'
            '<html lang="en">'
            '<head>'
            '<meta charset="UTF-8">'
            '<meta name="viewport" content="width=device-width, initial-scale=1.0">'
            '<title>Azure Tenant Discovery Results</title>'
            '<style>{css}</style>'
            '<script>{js}</script>'
            '</head>'
            '<body>'
            '<div class="container">'
            '<div class="header">'
            '<img style="transform: scale(0.70);" src="data:image/jpeg;base64,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" alt="ATEAM Logo" class="logo">'
            '<h1>Azure Tenant Discovery Results</h1>'
            '</div>'
            '<div class="timestamp">Generated on: {timestamp}</div>'
            '<div class="search-container">'
            '<input type="text" id="searchInput" class="search-input" placeholder="Search in all columns...">'
            '</div>'
            '<div id="noResults" class="no-results">No matching results found</div>'
            '<table>'
            '<thead>'
            '<tr>'
            '<th>Resource URI</th>'
            '<th>Type</th>'
            '<th>Tenant ID</th>'
            '<th>Company Name</th>'
            '<th>Discovered At</th>'
            '</tr>'
            '</thead>'
            '<tbody>'
            '{rows}'
            '</tbody>'
            '</table>'
            '</div>'
            '</body>'
            '</html>'
        )

        # Generate table rows
        rows = []
        for row in results:
            # Decode HTML entities in company display name if present
            company_name = row[3] or ""
            if company_name:
                # Handle double-escaped Unicode sequences first
                if '\\u' in company_name:
                    company_name = company_name.encode('utf-8').decode('unicode_escape')
                # Then decode HTML entities
                import html
                company_name = html.unescape(company_name)
            
            rows.append(
                '<tr>'
                f'<td>{row[0]}</td>'
                f'<td class="resource-type">{row[1]}</td>'
                f'<td class="tenant-id">{row[2]}</td>'
                f'<td class="company-name">{company_name}</td>'
                f'<td>{row[4]}</td>'
                '</tr>'
            )
        
        # Format the HTML with the data
        html_content = html_template.format(
            css=css,
            js=js,
            timestamp=datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            rows=''.join(rows)
        )
        
        # Write to file
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write(html_content)

    def clear_database(self):
        """Clear all entries from the database."""
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute('DELETE FROM resource_info')
            conn.commit()
            logger.info("Database cleared successfully")

    def show_database_contents(self, tenant_id: Optional[str] = None):
        """Show the contents of the database in a formatted table.
        
        Args:
            tenant_id: If provided, only show resources with this tenant ID.
        """
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            
            query = '''
                SELECT resource_uri, resource_type, tenant_id, company_display_name, discovered_at
                FROM resource_info 
            '''
            params = []
            
            if tenant_id:
                query += ' WHERE tenant_id = ?'
                params.append(tenant_id)
                
            query += ' ORDER BY resource_type, resource_uri'
            
            cursor.execute(query, params)
            results = cursor.fetchall()
            
            if not results:
                print("\nNo resources found in the database.")
                return
                
            print("\nDatabase Contents:")
            print("-" * 100)
            print(f"{'Resource URI':<40} {'Type':<15} {'Tenant ID':<30} {'Company':<20} {'Discovered At':<20}")
            print("-" * 100)
            
            for resource_uri, resource_type, tenant_id, company_display_name, discovered_at in results:
                # Decode HTML entities in company display name if present
                company_name = company_display_name or "N/A"
                if company_name != "N/A":
                    # Handle double-escaped Unicode sequences first
                    if '\\u' in company_name:
                        company_name = company_name.encode('utf-8').decode('unicode_escape')
                    # Then decode HTML entities
                    import html
                    company_name = html.unescape(company_name)
                print(f"{resource_uri:<40} {resource_type:<15} {tenant_id:<30} {company_name:<20} {discovered_at:<20}")
                
            print(f"\nTotal resources: {len(results)}")

def main():
    # Parse command line arguments
    parser = argparse.ArgumentParser(description='Azure Tenant ID Discovery Tool')
    parser.add_argument('-f', '--file', help='File containing resources to check (one per line)')
    parser.add_argument('-r', '--resources', nargs='+', help='Space-separated list of resources to check')
    parser.add_argument('-w', '--workers', type=int, default=10, help='Number of concurrent workers (default: 10)')
    parser.add_argument('-b', '--batch-size', type=int, default=1000, help='Number of resources to process in each batch (default: 1000)')
    parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose logging')
    parser.add_argument('-l', '--list', action='store_true', help='List all entries in the database without scanning')
    parser.add_argument('-e', '--export', choices=['csv', 'json', 'html'], help='Export results to specified format (csv, json, html)')
    parser.add_argument('--clear', action='store_true', help='Clear the database before scanning')
    parser.add_argument('-t', '--tenant', help='Filter results to show only resources with this tenant ID')
    parser.add_argument('-p', '--permutations', nargs='?', const='default', help='Generate permutations of resource names using the specified file (default: permutations.txt)')
    args = parser.parse_args()

    # Initialize the finder with verbose flag
    finder = AzureTenantFinder(verbose=args.verbose)
    
    # Clear database if requested
    if args.clear:
        finder.clear_database()
    
    # If list option is specified, show database contents and optionally export
    if args.list:
        finder.show_database_contents(args.tenant)
        
        # Export if explicitly requested
        if args.export:
            print(f"\nExporting database contents in {args.export} format...")
            finder.export_results(args.export, tenant_id=args.tenant)
        
        return

    # Get resources from file or command line
    resources = []
    if args.file:
        try:
            with open(args.file, 'r') as f:
                resources.extend([line.strip() for line in f if line.strip()])
        except Exception as e:
            print(f"Error reading file: {str(e)}")
            sys.exit(1)
    
    if args.resources:
        resources.extend(args.resources)
    
    # Check if export is requested without resources
    if args.export and not resources:
        print(f"No resources provided. Exporting entire database in {args.export} format...")
        finder.export_results(args.export, tenant_id=args.tenant)
        return
    
    # Check if any resources were provided for discovery
    if not resources:
        print("No resources provided. Please specify resources using -r or -f options.")
        print("Use --help for more information.")
        sys.exit(1)
    
    # If using permutations, inform the user
    if args.permutations:
        if args.permutations == 'default':
            print(f"Generating permutations of {len(resources)} base resource names using default permutations.txt...")
            print("WARNING: This will generate approximately 329 resources per base resource (1 + 82*4 permutations).")
            print("Consider using a smaller batch size (e.g., -b 100) if you experience memory issues.")
        else:
            print(f"Generating permutations of {len(resources)} base resource names using {args.permutations}...")
            print("WARNING: Permutations can generate a large number of resources. Consider using a smaller batch size if needed.")
    else:
        print(f"Starting Azure Tenant ID discovery for {len(resources)} resources...")
    
    # Record start time before any processing
    run_start_time = datetime.now()
    logger.debug(f"Run start time: {run_start_time}")
    
    # Process resources with permutations flag
    finder.process_resources(resources, max_workers=args.workers, use_permutations=args.permutations, batch_size=args.batch_size)
    
    print("\nDiscovery complete. Resources added to database.")
    
    # Export results only if explicitly requested
    if args.export:
        print(f"Exporting results in {args.export} format...")
        finder.export_results(args.export, tenant_id=args.tenant, run_timestamp=run_start_time)

if __name__ == "__main__":
    main()