Más allá del escáner: Diseño de un panel interactivo DevSecOps para análisis de seguridad móvil (SAST) con Python, Streamlit y Plotly.

Resumen ejecutivo: El panorama de la seguridad en aplicaciones móviles enfrenta una crisis de visibilidad. Con la adopción de arquitecturas nativas de la nube, las aplicaciones de Android (APK) a menudo ocultan credenciales codificadas de forma rígida (hardcoded secrets), configuraciones de red inseguras y vulnerabilidades criptográficas. Las herramientas tradicionales de Pruebas de Seguridad de Aplicaciones Estáticas (SAST) como SonarCloud o Snyk generan reportes masivos en formato JSON o PDF que los equipos de desarrollo rara vez priorizan de manera efectiva.

En este artículo, explicamos cómo desarrollamos un panel interactivo de inteligencia de seguridad (DevSecOps) en Python puro utilizando Streamlit y Plotly, respaldado por más de 5,000 hallazgos de vulnerabilidades en aplicaciones móviles, una canalización automatizada de GitOps CI/CD con GitHub Actions y despliegue continuo en la nube a través de Azure Container Apps.

Enlaces del proyecto:

• Panel de control DevSecOps en la nube
• Repositorio de GitHub
• Canalización de CI/CD automatizada
• Esquema de datos SAST

El desafío de la seguridad móvil: sobrecarga de alertas vs. remediación

La eficiencia de los equipos de ciberseguridad depende de su capacidad para clasificar, priorizar y mitigar riesgos antes de que el código llegue a producción. Para los ingenieros DevSecOps y los desarrolladores móviles, la gestión de vulnerabilidades presenta un problema multivariable:

• ¿Cómo diferenciamos un "Falso Positivo" de una vulnerabilidad crítica (CVSS > 9.0) en una base de código de 500,000 líneas?
• ¿Qué porcentaje de nuestra deuda técnica de seguridad proviene de dependencias de terceros (Snyk) frente a código mal estructurado (SonarCloud)?
• ¿Cuántos tokens de acceso a bases de datos o claves de API de AWS están expuestos en texto plano dentro de los archivos classes.dex del APK?
• ¿Cómo proyectamos el esfuerzo de ingeniería (en horas) necesario para remediar las vulnerabilidades de inyección SQL (CWE-89) en el próximo sprint?

Históricamente, las auditorías de seguridad móvil dependían de procesos manuales o plataformas aisladas que presentaban limitaciones:

• Fatiga de alertas (Alert Fatigue): Los escáneres estáticos arrojan miles de advertencias de nivel informativo que ocultan las vulnerabilidades críticas.
• Falta de contexto visual: Los archivos JSON sin procesar generados por los motores SAST no permiten a los gerentes técnicos tomar decisiones rápidas sobre qué parchear primero.
• Silos entre Seguridad y Desarrollo: Los reportes estáticos no permiten simulaciones de tipo "What-If" para calcular cómo mejoraría el puntaje de riesgo global si se corrigen solo 10 dependencias clave.

Para resolver esto, diseñamos un panel web interactivo que transforma los datos crudos de ingeniería inversa y análisis estático en una herramienta de triaje visual en tiempo real.

Selección de la cadena de herramientas: el caso de Streamlit + Plotly

La elección de Streamlit permitió integrar directamente scripts de Python que parsean manifiestos de Android (AndroidManifest.xml) y resultados de descompilación directamente en la memoria del dashboard, complementado con la interactividad de Plotly.

🔒 La capa de datos: telemetría de vulnerabilidades (SAST & SCA)

El panel no utiliza datos sintéticos simples, sino que ingiere y normaliza resultados de motores de análisis estático (SAST) y análisis de composición de software (SCA).

Especificaciones del motor de datos

• Área de estudio: Seguridad en aplicaciones móviles (Android/APK), ingeniería inversa, triaje de vulnerabilidades.
• Fuentes de ingesta analizadas:
  • Análisis estático (SAST): reglas personalizadas, SonarCloud.
  • Detección de secretos: Gitleaks, detectores de entropía.
• Volumen: +5,000 hallazgos históricos catalogados.

Parámetros clave

Decisión arquitectónica: caché en memoria para JSON masivos

Dado que los escaneos de seguridad generan archivos JSON de varios megabytes, utilizamos @st.cache_data para cargar los dataframes en la memoria del servidor de Streamlit solo una vez por sesión, reduciendo el tiempo de renderizado de los gráficos a milisegundos tras la carga inicial.

📊 Dentro del motor analítico: 5 módulos principales

El sistema se divide en cinco perspectivas para facilitar el triaje de seguridad:

1. Matriz de Riesgo y Postura Global: Distribución de severidad y deuda técnica.
2. Mapa de Calor de Debilidades (CWE Treemap): Visión jerárquica de los vectores de ataque más comunes.
3. Radar de Secretos Expuestos: Filtro específico para credenciales hardcodeadas (claves API, tokens).
4. Simulador de Remediación (What-If): Deslizadores para proyectar la reducción del riesgo si el equipo dedica N horas al sprint de seguridad.
5. Generador de Reportes Ejecutivos: Exportación automatizada filtrada para los stakeholders.

A continuación, un extracto del código que genera el Mapa de Calor Jerárquico (Treemap) para categorizar vulnerabilidades por severidad y tipo:

`import streamlit as st
import pandas as pd
import plotly.express as px

# Ingesta en caché de resultados SAST
@st.cache_data
def load_security_scan():
    # En producción esto lee de Supabase o archivos JSON en S3
    return pd.read_parquet("data/sast_results.parquet")

df = load_security_scan()

st.subheader("Mapa de Calor de Vulnerabilidades por CWE")

# Filtros interactivos en la barra lateral
severity_filter = st.sidebar.multiselect(
    "Filtrar por Severidad",
    options=["Critical", "High", "Medium", "Low"],
    default=["Critical", "High"]
)

filtered_df = df[df["Severity"].isin(severity_filter)]

# Agrupación de datos para el Treemap
treemap_data = filtered_df.groupby(["Severity", "CWE_Category"]).size().reset_index(name="Count")

# Renderizado de Plotly Express
fig = px.treemap(
    treemap_data, 
    path=["Severity", "CWE_Category"], 
    values="Count",
    color="Severity",
    color_discrete_map={
        "Critical": "#8B0000", 
        "High": "#FF4500", 
        "Medium": "#FFA500", 
        "Low": "#2E8B57"
    },
    title="Distribución Jerárquica de Deuda Técnica de Seguridad"
)

fig.update_layout(margin=dict(t=50, l=25, r=25, b=25), template="plotly_dark")
st.plotly_chart(fig, use_container_width=True)`

🏛️ System Architecture & GitOps Pipeline

+-----------------------------------------------------------------------------------------+
|                                    1. DATA LAYER                                        |
|  [ data/sast_results.parquet ]                             [ CI/CD Artifacts (JSON) ]   |
|  (5,000+ Normalized Vulnerability Findings)                (SonarCloud / Snyk outputs)  |
+-----------------------------------------------------------------------------------------+
                                      │
                                      ▼ (Data Ingestion)
+-----------------------------------------------------------------------------------------+
|                       2. APPLICATION CORE & CACHING LAYER                               |
|  • @st.cache_data(ttl=3600) Fast In-Memory Parsing of Security Artifacts                |
|  • Pandas Filtering Engine (By Component, Severity, CVSS Score, CWE Type)               |
|  • Automated Risk Scoring Algorithms                                                    |
+-----------------------------------------------------------------------------------------+
                                      │
                                      ▼ (Reactive Dataframes)
+-----------------------------------------------------------------------------------------+
|                         3. ANALYTICAL MODULES & SEC ENGINES                             |
|  ┌───────────────────────┐ ┌───────────────────────┐ ┌───────────────────────────────┐  |
|  | Module 1: Risk Matrix | | Module 2: CWE Heatmap | | Module 3: Secrets Radar       |  |
|  | • CVSS Distributions  | | • Plotly Treemap      | | • Hardcoded Token Alerts      |  |
|  | • Tech Debt (Hours)   | | • Dependency Trees    | | • Entropy Analysis Viewer     |  |
|  └───────────────────────┘ └───────────────────────┘ └───────────────────────────────┘  |
|  ┌─────────────────────────────────────────────────┐ ┌───────────────────────────────┐  |
|  | Module 4: What-If Mitigation Simulator          | | Module 5: Audit Export        |  |
|  | • Adjust Sprint Hours for Security              | | • Dynamic DataTable           |  |
|  | • Calculate Projected Risk Reduction            | | • Generate Compliance CSV/PDF |  |
|  └─────────────────────────────────────────────────┘ └───────────────────────────────┘  |
+-----------------------------------------------------------------------------------------+
                                      │
                                      ▼ (git push origin main)
+-----------------------------------------------------------------------------------------+
|                             4. DEVSECOPS & CI/CD PIPELINE                               |
|  [ GitHub Repository ] ──► [ GitHub Actions Runner ] ──► [ Azure Container Apps ]       |
|  • Version Control         • Terraform Provisioning      • Docker Image Build           |
|  • Branch: main            • Snyk Container Scan         • Managed Cloud Run (SaaS)     |
|                            • Flake8/Bandit Linting       • Secure HTTPS Endpoint        |
+-----------------------------------------------------------------------------------------+