SurfaceScan: Herramienta de Detección de Superficie de Ataque

Génesis del Producto

El Problema

En mi experiencia protegiendo organizaciones, observé un patrón recurrente: la brecha entre los activos que las empresas creen tener expuestos y lo que realmente está visible desde internet es significativa.

Estadísticas Observadas:

• 43% de brechas involucran activos desconocidos
• Inventarios de activos desactualizados en 78% de casos
• Tiempo medio para descubrir nuevo activo expuesto: 45 días
• Shadow IT representa 30-40% de superficie de ataque real

La Oportunidad

Existía espacio para una herramienta que:

• Automatizara el descubrimiento completo
• Fuera accesible para organizaciones medianas
• Proporcionara resultados accionables, no solo datos
• Operara de forma continua, no puntual
• Integrara múltiples fuentes de información

Arquitectura Técnica

Stack Tecnológico

┌─────────────────────────────────────────────────────────────┐
│                    Frontend (Dashboard)                      │
│              React │ TypeScript │ TailwindCSS               │
├─────────────────────────────────────────────────────────────┤
│                       API Gateway                            │
│                  Kong │ Rate Limiting │ Auth                │
├─────────────────────────────────────────────────────────────┤
│                    Backend Services                          │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │Discovery │  │ Scanner  │  │Analytics │  │ Reporter │   │
│  │ Engine   │  │ Engine   │  │ Engine   │  │ Engine   │   │
│  │  (Go)    │  │ (Python) │  │ (Python) │  │ (Python) │   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
├─────────────────────────────────────────────────────────────┤
│                    Message Queue (Redis)                     │
├─────────────────────────────────────────────────────────────┤
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │  PostgreSQL  │  │Elasticsearch │  │    Redis     │      │
│  │   (Assets)   │  │   (Logs)     │  │   (Cache)    │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
├─────────────────────────────────────────────────────────────┤
│                    Infrastructure                            │
│           Kubernetes │ Terraform │ GitHub Actions           │
└─────────────────────────────────────────────────────────────┘

Módulos Principales

1. Discovery Engine

Responsable del descubrimiento de activos:

class DiscoveryEngine:
    """Motor de descubrimiento de superficie de ataque"""

    def __init__(self, target_domain: str):
        self.domain = target_domain
        self.discovered_assets = []
        self.sources = [
            SubdomainEnumeration(),
            DNSRecords(),
            CertificateTransparency(),
            PassiveDNS(),
            WebArchive(),
            SearchEngines(),
            GitHubDorking(),
            CloudEnumeration()
        ]

    async def discover(self) -> List[Asset]:
        """Ejecuta descubrimiento paralelo de múltiples fuentes"""
        tasks = [source.enumerate(self.domain) for source in self.sources]
        results = await asyncio.gather(*tasks)

        # Consolidación y deduplicación
        unique_assets = self.deduplicate(flatten(results))

        # Validación de activos vivos
        live_assets = await self.validate_live(unique_assets)

        return live_assets

Fuentes de Descubrimiento:

• Certificate Transparency logs
• DNS bruteforce inteligente
• Passive DNS histórico
• Wayback Machine
• Search engine dorking
• GitHub/GitLab exposure
• Cloud storage enumeration
• ASN/IP range analysis

2. Scanner Engine

Evaluación de vulnerabilidades:

class ScannerEngine:
    """Motor de escaneo de vulnerabilidades"""

    def __init__(self):
        self.scanners = [
            PortScanner(),
            ServiceIdentifier(),
            TechnologyDetector(),
            VulnerabilityScanner(),
            SSLAnalyzer(),
            HeaderAnalyzer(),
            ConfigurationChecker()
        ]

    async def scan_asset(self, asset: Asset) -> ScanResult:
        """Escaneo completo de un activo"""

        # Escaneo de puertos
        open_ports = await self.port_scan(asset)

        # Identificación de servicios
        services = await self.identify_services(asset, open_ports)

        # Detección de tecnologías
        technologies = await self.detect_technologies(asset)

        # Escaneo de vulnerabilidades
        vulnerabilities = await self.scan_vulnerabilities(
            asset, services, technologies
        )

        # Análisis de configuración
        misconfigs = await self.check_configurations(asset)

        return ScanResult(
            asset=asset,
            ports=open_ports,
            services=services,
            technologies=technologies,
            vulnerabilities=vulnerabilities,
            misconfigurations=misconfigs
        )

Categorías de Detección:

Categoría	Ejemplos
Puertos/Servicios	SSH, RDP, bases de datos expuestas
Tecnologías	CMS, frameworks, versiones
Vulnerabilidades	CVEs conocidos, exploits públicos
Configuraciones	SSL débil, headers faltantes
Exposures	Paneles admin, APIs sin auth
Leaks	Credenciales, código fuente

3. Analytics Engine

Priorización y scoring:

class RiskScorer:
    """Sistema de scoring de riesgo"""

    def calculate_risk(self, vulnerability: Vulnerability) -> RiskScore:
        """Calcula score de riesgo contextualizado"""

        base_score = vulnerability.cvss_score

        # Ajustes por contexto
        adjustments = {
            'exploit_available': 1.5 if vulnerability.has_exploit else 1.0,
            'internet_exposed': 1.3 if vulnerability.internet_facing else 1.0,
            'critical_asset': 1.4 if vulnerability.asset.is_critical else 1.0,
            'data_exposure': 1.2 if vulnerability.involves_data else 1.0,
            'age': self.age_factor(vulnerability.first_seen)
        }

        final_score = base_score
        for factor, multiplier in adjustments.items():
            final_score *= multiplier

        return RiskScore(
            base=base_score,
            adjusted=min(final_score, 10.0),
            factors=adjustments,
            priority=self.determine_priority(final_score)
        )

Factores de Priorización:

• CVSS base score
• Disponibilidad de exploit
• Exposición a internet
• Criticidad del activo
• Datos potencialmente afectados
• Tiempo de exposición

Funcionalidades Clave

Dashboard Ejecutivo

Vista General:

• Total de activos descubiertos
• Vulnerabilidades por severidad
• Tendencia de superficie de ataque
• Score de riesgo global
• Comparativa histórica

Drill-Down por Activo:

• Información detallada del asset
• Puertos y servicios
• Tecnologías detectadas
• Vulnerabilidades asociadas
• Histórico de cambios
• Evidencias de hallazgos

Alertas Proactivas

Triggers Configurables:

alertas:
  - nombre: "Nuevo activo crítico"
    condicion:
      tipo: nuevo_activo
      servicios: [SSH, RDP, Admin Panel]
    urgencia: alta
    notificacion: [email, slack, webhook]

  - nombre: "Vulnerabilidad crítica"
    condicion:
      tipo: nueva_vulnerabilidad
      cvss_min: 9.0
      exploit: true
    urgencia: critica
    notificacion: [email, slack, sms, webhook]

  - nombre: "Exposición de datos"
    condicion:
      tipo: data_exposure
      categorias: [credentials, source_code, pii]
    urgencia: critica
    notificacion: [email, slack, webhook]

Integración con Workflows

APIs Disponibles:

• REST API completa
• Webhooks de eventos
• Exportación de datos
• Integración con ticketing
• Conectores SIEM

Formatos de Export:

• JSON/CSV para análisis
• PDF para reporting ejecutivo
• Integración con Jira/ServiceNow
• Formato SARIF para DevSecOps

Resultados en Producción

Métricas de Efectividad

Descubrimiento:

• Assets descubiertos vs inventario: +340%
• Subdominios no documentados: 67% promedio
• Tiempo de descubrimiento: 15 min completo
• Falsos positivos: < 3%

Vulnerabilidades:

• CVEs detectados en pilotos: 12,000+
• Vulnerabilidades críticas: 234
• Tiempo medio de detección: < 24 horas
• Priorización efectiva: 89% accuracy

Casos de Uso Reales

Caso 1: Empresa de Retail

• Activos esperados: 45
• Activos descubiertos: 178
• Vulnerabilidades críticas: 12
• Hallazgo clave: Panel admin expuesto con credenciales por defecto

Caso 2: Entidad Financiera

• Activos esperados: 234
• Activos descubiertos: 456
• Vulnerabilidades críticas: 34
• Hallazgo clave: Base de datos de desarrollo accesible públicamente

Caso 3: Sector Salud

• Activos esperados: 67
• Activos descubiertos: 189
• Vulnerabilidades críticas: 8
• Hallazgo clave: API de pacientes sin autenticación

Roadmap del Producto

Funcionalidades Completadas

• Descubrimiento automatizado
• Escaneo de vulnerabilidades
• Dashboard ejecutivo
• Sistema de alertas
• API REST completa
• Reporting automatizado

Próximas Iteraciones

Q1 2025:

• Escaneo de cloud assets (AWS, Azure, GCP)
• Integración con pentest tools
• Machine learning para priorización

Q2 2025:

• Attack path analysis
• Breach & Attack Simulation básico
• Compliance mapping (ENS, ISO 27001)

Q3 2025:

• Dark web monitoring
• Credential leak detection
• Supply chain risk assessment

Lecciones de Desarrollo

Desafíos Técnicos

1. Escalabilidad de Escaneo

   • Solución: Arquitectura distribuida con workers
   • Rate limiting inteligente
   • Priorización de tareas

2. Precisión de Resultados

   • Validación multi-fuente
   • Fingerprinting avanzado
   • Reducción de false positives

3. Performance en Tiempo Real

   • Caching agresivo
   • Procesamiento incremental
   • Optimización de queries

Aprendizajes Clave

• Producto > Tecnología: Resolver el problema real, no mostrar capacidades técnicas
• Feedback Temprano: Pilotos con clientes reales desde el inicio
• Simplicidad: Resultados accionables, no datos abrumadores
• Automatización: Reducir fricción para el usuario final

SurfaceScan representa la convergencia de experiencia en seguridad ofensiva y defensiva, transformando el conocimiento de campo en una herramienta que ayuda a las organizaciones a ver lo que ven los atacantes antes de que sea demasiado tarde.