Nov 20, 2026·9 min read·1 visit
CKAN fails to regenerate session identifiers during automatic authentication after user registration when using server-side session storage. Upgrading to CKAN 2.10.11, 2.11.6, or 2.12.0 resolves the issue by forcing session regeneration prior to login.
A session fixation vulnerability (CWE-384) exists in CKAN (Comprehensive Knowledge Archive Network) prior to versions 2.10.11 and 2.11.6. When configured with server-side session storage and active public web registration, the user registration view programmatically authenticates newly created accounts without regenerating the active session identifier. An attacker capable of fixing or capturing a victim's pre-authentication session cookie can hijack the newly registered account immediately after registration completes.
CKAN (Comprehensive Knowledge Archive Network) is an open-source data management system used by governments, academic institutions, and organizations to operate public and internal data portals. The platform relies on a Flask-based web architecture that manages user authentication, dataset publication, and granular access controls through configurable session interfaces.
CVE-2026-104773 (also tracked as GHSA-6499-jgj4-2wpf) is a Session Fixation vulnerability classified under CWE-384 within CKAN's user management views (ckan/views/user.py). When a new user completes the web registration form, CKAN automatically authenticates the newly created account to transition the user directly into an active portal session. During this privilege transition, the registration handler fails to invoke session regeneration on the underlying session interface.
While CKAN defaults to client-side signed cookies and disables public web registration out of the box, deployments configured with server-side session backends (such as Redis, memcached, or relational database stores) and self-service registration (ckan.auth.create_user_via_web = True) are exposed. In these configurations, the pre-authentication session key remains bound to the newly elevated session state.
An unauthenticated attacker who can pre-seed or read a victim's session identifier prior to registration can reuse that identifier once the victim submits the registration form. This grants the attacker full access to the victim's newly registered CKAN account, compromising the confidentiality and integrity of any datasets, API tokens, or organizational memberships tied to that user.
In web applications utilizing server-side session storage, a session identifier stored in a client cookie acts as a lookup key pointing to an authoritative session record on the server. When a user crosses an authentication boundary—transitioning from an anonymous visitor to an authenticated account—the application must invalidate the anonymous session key and generate a cryptographically random replacement key. Failure to rotate this identifier allows any entity aware of the pre-authentication key to assume the identity associated with the post-authentication state.
In CKAN, user authentication occurs across two distinct workflows in ckan/views/user.py: standard credential login (login()) and programmatic post-registration login (RegisterView.post()). In the standard login() function, the developers previously implemented session rotation by checking whether current_app.session_interface provided a regenerate method and invoking it against the active session object.
However, this rotation logic was omitted from the post() method handling user registration submissions. When a visitor submits a valid registration request to /user/register, the controller invokes the user_create logic action to commit the new user entity to the database. It then retrieves the model.User instance, calls login_user(userobj) to populate the session with the authenticated user context, and invokes rotate_token() to refresh the CSRF token.
Because rotate_token() only updates the anti-CSRF value stored inside the session payload without instructing current_app.session_interface to rotate the outer session lookup key, the server-side session backend simply updates the existing session record in place. The client browser never receives a new Set-Cookie header with a rotated session identifier, leaving the pre-registration session ID permanently promoted to an authenticated session.
The vulnerability and its remediation are localized to ckan/views/user.py. Prior to the patch, the session regeneration routine was inline within login(), while post() in the registration view executed login_user(userobj) directly on the unrotated session.
In the unpatched code inside ckan/views/user.py, the registration handler proceeds as follows:
# Unpatched registration post() handler in ckan/views/user.py
# log the user in programmatically
userobj = model.User.get(user_dict["id"])
if userobj:
# DEFECT: Session ID is not regenerated before binding userobj to the session
login_user(userobj)
rotate_token()
resp = h.redirect_to(u'user.me')The official patch (committed in 6eae4e9c430e163b9d6cc75a3fd2ca82e79d80f6 and backported across active release branches) abstracts the session rotation logic into a dedicated helper function named regenerate_session() and invokes it across both authentication paths.
File: ckan/views/user.py
@@ -475,6 +475,7 @@ def post(self) -> Union[Response, str]:
# log the user in programmatically
userobj = model.User.get(user_dict["id"])
if userobj:
+ regenerate_session()
login_user(userobj)
rotate_token()
resp = h.redirect_to(u'user.me')
@@ -548,9 +549,7 @@ def login() -> Union[Response, str]:
user_obj = authenticator.ckan_authenticator(identity)
if user_obj:
next = request.args.get('next', request.args.get('came_from'))
- regenerate = getattr(current_app.session_interface, 'regenerate', None)
- if regenerate is not None:
- regenerate(session)
+ regenerate_session()
if _remember:
from datetime import timedelta
duration_time = timedelta(milliseconds=int(_remember))
@@ -572,6 +571,12 @@ def login() -> Union[Response, str]:
return base.render("user/login.html", extra_vars)
+def regenerate_session() -> None:
+ regenerate = getattr(current_app.session_interface, 'regenerate', None)
+ if regenerate is not None:
+ regenerate(session)
+
+
def logout() -> Response:
for item in plugins.PluginImplementations(plugins.IAuthenticator):
response = item.logout()By calling regenerate_session() immediately prior to login_user(userobj), CKAN queries current_app.session_interface for a regenerate method. If a server-side session interface providing regenerate is active, it invalidates the old session identifier in the backing store and assigns a new session key before login_user() writes the authenticated user attributes.
> [!NOTE]
> Regarding fix completeness, regenerate_session() relies on duck typing (getattr(current_app.session_interface, 'regenerate', None)). If an administrator integrates a custom third-party Flask session interface that uses a different method name for session rotation (e.g., cycle_key() or rotate()) rather than regenerate(), session rotation will silently become a no-op. Standard CKAN server-side session interfaces implement regenerate().
Exploiting CVE-2026-104773 requires three conditions: the target CKAN instance must use server-side session storage, public web registration (ckan.auth.create_user_via_web = True) must be enabled, and the attacker must be able to fix or observe the victim's session cookie before the victim completes registration.
An attacker typically establishes the fixed session through one of three delivery mechanisms:
data.example.org and the attacker controls or discovers a Cross-Site Scripting (XSS) flaw on a sibling subdomain such as blog.example.org, the attacker can issue a Set-Cookie: ckan=<FIXED_SESSION_ID>; Domain=.example.org; Path=/ header or JavaScript assignment. The victim's browser will include this pre-seeded cookie when navigating to data.example.org/user/register./user/register, records the assigned ckan session cookie value from the browser developer tools, and leaves the registration page open for the next user.Secure cookie attributes or HTTP Strict Transport Security (HSTS), a network attacker on a shared local network can inject the session cookie over an unencrypted HTTP response.To verify whether a target configuration is vulnerable in a controlled testing environment, a security engineer can trace the HTTP headers across the registration lifecycle:
# Step 1: Request the registration form and record the initial session cookie
GET /user/register HTTP/1.1
Host: ckan.example.org
HTTP/1.1 200 OK
Set-Cookie: ckan=8a9f7c6b5d4e3f2a1b0c9d8e7f6a5b4c; Path=/; HttpOnly# Step 2: Submit the registration form using the initial session cookie
POST /user/register HTTP/1.1
Host: ckan.example.org
Cookie: ckan=8a9f7c6b5d4e3f2a1b0c9d8e7f6a5b4c
Content-Type: application/x-www-form-urlencoded
name=test_researcher&email=researcher%40example.org&password1=StrongPass123!&password2=StrongPass123!&_csrf_token=...
HTTP/1.1 302 Found
Location: https://ckan.example.org/user/me
# If vulnerable, no rotated 'ckan' session identifier is issued in Set-Cookie, and the old ID remains valid for /user/me.Once the victim submits the registration form, the server associates the newly created account with 8a9f7c6b5d4e3f2a1b0c9d8e7f6a5b4c. The attacker can then pass Cookie: ckan=8a9f7c6b5d4e3f2a1b0c9d8e7f6a5b4c from their own client to access /user/me, generate permanent CKAN API keys, or interact with restricted organizational datasets.
CVE-2026-104773 is rated with a CVSS v3.1 base score of 6.8 (Medium) under the vector CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:N. The High Attack Complexity (AC:H) and Required User Interaction (UI:R) metrics reflect the non-default configuration prerequisites and the necessity for an attacker to both fix a session identifier in the victim's browser and wait for the victim to register a new account.
Despite the elevated complexity, successful exploitation yields High Confidentiality (C:H) and High Integrity (I:H) impacts within the scope of the compromised user account. In many CKAN enterprise and government deployments, users register using corporate or institutional email addresses and are subsequently invited to private organizations or granted dataset publishing privileges based on their verified identity.
An attacker who hijacks the session at the moment of registration maintains stealthy concurrent access alongside the legitimate user. Furthermore, because CKAN allows authenticated users to generate persistent API tokens through the web interface, the attacker can immediately mint an API token to maintain long-term access even after the fixed web session eventually expires or the user logs out.
As of the current threat intelligence assessment, the EPSS score for CVE-2026-104773 is 0.00327 (26.49th percentile), indicating a low probability of widespread automated exploitation in the wild. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, as exploitation cannot be trivially automated without a secondary vector to plant or intercept session cookies.
The primary remediation is to upgrade CKAN to a patched release that enforces session regeneration upon registration. The fix is included in CKAN versions 2.10.11, 2.11.6, and 2.12.0. Administrators should update their deployments to the corresponding patched release for their active minor branch.
For environments where an immediate version upgrade is blocked by custom plugin compatibility or change management windows, administrators can eliminate the attack surface through configuration adjustments in ckan.ini (or production.ini). If public self-registration is not a strict operational requirement, ensure web registration is disabled:
# Disable self-service account creation via the web interface
ckan.auth.create_user_via_web = FalseIf web registration must remain active prior to patching, administrators should evaluate whether server-side session storage is strictly required. Reverting to CKAN's default signed client-side cookie sessions prevents server-side session key fixation. Additionally, enforcing strict cookie security policies and HTTP Strict Transport Security (HSTS) reduces the avenues available for an attacker to inject or intercept session cookies across the network or from untrusted subdomains:
# Harden session cookie flags in ckan.ini
ckan.webcontent.session_cookie_name = ckan
ckan.webcontent.session_cookie_secure = True
ckan.webcontent.session_cookie_httponly = True
ckan.webcontent.session_cookie_samesite = LaxSecurity operations teams can also monitor reverse proxy and application access logs for indicators of session fixation. Specifically, defenders should alert on instances where a session token observed requesting GET /user/register and POST /user/register from one IP address and User-Agent subsequently performs authenticated actions (such as accessing /user/me or generating API tokens) from a disparate autonomous system number (ASN), IP subnet, or browser fingerprint.
CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
CKAN ckan | < 2.10.11 | 2.10.11 |
CKAN ckan | >= 2.11.0, < 2.11.6 | 2.11.6 |
| Attribute | Detail |
|---|---|
| CWE Classification | CWE-384: Session Fixation |
| CVSS v3.1 Score | 6.8 Medium (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:N) |
| EPSS Score | 0.33% (26.49th Percentile) |
| Affected Component | ckan/views/user.py (Registration POST Handler) |
| Prerequisites | Server-side sessions enabled + ckan.auth.create_user_via_web = True |
| Security Impact | Account Takeover of newly registered user sessions |
| Exploit Status | None (No public weaponized exploits) |
| CISA KEV Status | Not Listed |
Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions.
CVE-2026-35374 is a Time-of-Check to Time-of-Use (TOCTOU) race condition (CWE-367) in the split utility of uutils coreutils. The utility validates that the input and output paths do not refer to the same file before opening the output file with truncation flags. A local attacker with write permissions in the destination directory can replace the output file path with a symbolic link during this race window, causing the process to truncate and overwrite arbitrary files accessible to the user executing split.
CVE-2026-35377 is an improper input validation vulnerability (CWE-20) in the env utility of uutils coreutils, the Rust-based reimplementation of GNU coreutils. When processing command-line arguments with the -S (--split-string) option, the uutils split-string tokenizer erroneously validates backslash sequences enclosed within single quotes against a fixed table of known escape characters. Under standard GNU env behavior, backslashes inside single quotes are treated literally (except for \\ and \'). Because uutils rejects unrecognized sequences such as \a, \x, or \| with exit code 125, automated scripts, shebang invocations, and administrative workflows relying on POSIX/GNU compatibility fail to execute, resulting in a local denial of service.
A Time-of-Check to Time-of-Use (TOCTOU) race condition in the chcon utility of uutils coreutils prior to version 0.8.0 allows a local attacker with write access to a directory tree undergoing recursive SELinux context relabeling to redirect extended attribute modifications to arbitrary system files.
A line delimiter injection vulnerability in Git Large File Storage (Git LFS) versions 0.6.0 through 3.8.0 allows remote attackers to execute arbitrary commands via crafted Git submodule URLs containing embedded line feed characters.
CVE-2026-105803 (GHSA-x72p-hmqp-46hw) is a high-severity arbitrary command execution vulnerability in Git Large File Storage (Git LFS) affecting versions from v1.3.0 prior to v3.8.1. The flaw stems from the combination of an unanchored regular expression in custom transfer adapter initialization (CWE-777) and insufficient syntactic validation during .lfsconfig key filtering (CWE-1286). An attacker can craft a repository containing a malicious .lfsconfig file that bypasses safe-key filtering restrictions and registers an arbitrary binary as a custom transfer adapter, leading to remote code execution when a victim clones or fetches from the repository.
An unauthenticated SQL injection vulnerability exists in Daptin prior to version 0.12.30. The generic entity listing handler fails to validate user-supplied sort parameters against the table schema before passing them to the goqu SQL query builder, enabling remote attackers to break out of SQL identifier quoting and execute arbitrary SQL subqueries.