Skip to content

Latest commit

 

History

History
62 lines (51 loc) · 6.75 KB

threat-modeling.md

File metadata and controls

62 lines (51 loc) · 6.75 KB

Threat Model Analysis for chroma-core/chroma

Threat: Unauthorized Data Modification via API

  • Description: An attacker, without proper authentication, sends crafted HTTP requests to the Chroma API (e.g., POST /api/v1/add, POST /api/v1/update, POST /api/v1/delete) to add, modify, or delete embeddings and associated metadata. The attacker might use common API attack techniques like parameter tampering or injection.
    • Impact: Data integrity compromise, leading to incorrect search results, biased AI model behavior, or complete data loss. Could also lead to data poisoning if the attacker inserts malicious embeddings.
    • Affected Chroma Component: Chroma API Server (specifically, the endpoints handling data modification: /add, /update, /delete, and related functions within chromadb/api/fastapi.py and chromadb/server/fastapi/__init__.py and data validation logic in chromadb/api/models/Collection.py).
    • Risk Severity: Critical
    • Mitigation Strategies:
      • Implement strong authentication for all API endpoints using API keys, JWTs, or mTLS. Enforce authentication before any data processing.
      • Implement robust input validation and sanitization on all API parameters to prevent injection attacks. Validate data types, lengths, and formats. Use a schema validation library.
      • Implement authorization checks to ensure that authenticated users only have access to the data and operations they are permitted to use. Use a role-based access control (RBAC) system.

Threat: Denial of Service via Excessive Embedding Additions

  • Description: An attacker sends a large number of POST /api/v1/add requests with validly formatted but potentially meaningless embeddings, overwhelming Chroma's storage and processing capacity. This could exhaust disk space, memory, or CPU resources.
    • Impact: Chroma server becomes unresponsive, preventing legitimate users from accessing or using the service. Potential data loss if disk space is completely exhausted.
    • Affected Chroma Component: Chroma API Server (chromadb/api/fastapi.py), Embedding Storage (chromadb/db/* - specifically, the chosen database implementation like DuckDB or ClickHouse), and potentially the embedding generation component if it's integrated with Chroma.
    • Risk Severity: High
    • Mitigation Strategies:
      • Implement rate limiting on the /add endpoint, restricting the number of additions per client/IP address/time window.
      • Implement resource quotas (disk space, memory) for individual collections or users.
      • Monitor resource usage (CPU, memory, disk I/O) and trigger alerts when thresholds are exceeded.
      • Use a scalable database backend (e.g., ClickHouse) that can handle large volumes of data.

Threat: Denial of Service via Complex Similarity Queries

  • Description: An attacker crafts computationally expensive similarity search queries (POST /api/v1/get, POST /api/v1/query) using large n_results values, high-dimensional embeddings, or inefficient distance metrics. This exploits the computational complexity of nearest neighbor search.
    • Impact: Chroma server becomes unresponsive due to high CPU and memory usage, impacting all users.
    • Affected Chroma Component: Chroma API Server (chromadb/api/fastapi.py), Query Engine (chromadb/segment/ and related index implementations like HNSW in chromadb/segment/impl/index/hnswlib.py), Distance Calculation functions (chromadb/utils/distance_fns.py).
    • Risk Severity: High
    • Mitigation Strategies:
      • Limit the maximum value of n_results that can be requested.
      • Implement query timeouts to terminate long-running queries.
      • Provide options for users to select less computationally expensive distance metrics (e.g., cosine similarity instead of Euclidean distance if appropriate).
      • Optimize indexing strategies (e.g., using appropriate HNSW parameters) to improve query performance.
      • Consider pre-computing and caching results for frequently used queries.

Threat: Configuration File Tampering

  • Description: An attacker gains access to the Chroma server's file system and modifies the configuration file (e.g., chroma_server.yaml or environment variables), disabling security features, changing persistence settings, or altering logging configurations.
    • Impact: Weakened security posture, potential data loss, or inability to audit actions. Could lead to other vulnerabilities becoming exploitable.
    • Affected Chroma Component: Chroma Server startup and configuration loading logic (chromadb/config.py, chromadb/server/*).
    • Risk Severity: High
    • Mitigation Strategies:
      • Store the configuration file in a secure location with restricted access permissions (read-only for most users, write access only for designated administrators).
      • Use a configuration management tool (e.g., Ansible, Chef, Puppet) to manage and enforce consistent configurations.
      • Implement file integrity monitoring to detect unauthorized changes to the configuration file.
      • Use environment variables for sensitive configuration settings (e.g., API keys, database credentials) instead of storing them directly in the configuration file.

Threat: Dependency Vulnerabilities (High/Critical Impact)

  • Description: Chroma depends on various third-party libraries. High or critical vulnerabilities in these dependencies could be exploited to compromise Chroma, leading to severe consequences.
    • Impact: Varies depending on the specific vulnerability, but high or critical vulnerabilities could lead to remote code execution, complete data compromise, or complete denial of service.
    • Affected Chroma Component: Potentially any component that uses the vulnerable dependency.
    • Risk Severity: High/Critical (depending on the specific vulnerability)
    • Mitigation Strategies:
      • Regularly update Chroma and its dependencies to the latest versions.
      • Use a software composition analysis (SCA) tool to identify and track known vulnerabilities in dependencies, prioritizing high and critical severity issues.
      • Consider using a dependency pinning strategy to control the specific versions of dependencies used.
      • Monitor security advisories for the dependencies used by Chroma, focusing on high and critical alerts.