Summary
Helicone's vault key endpoint does not verify that the requesting administrator belongs to the organization associated with the requested provider key. As a result, an admin or owner from one organization may retrieve decrypted provider credentials belonging to another tenant.
Affected context
The vulnerability occurs in deployments where Helicone exposes the
/v1/vault/key/{providerKeyId} endpoint and permits organization-level
administrators or owners to request provider keys. Risk exists when the
endpoint relies on the supplied key identifier without enforcing an
organization-ownership relationship between the requester and the vault
record.
Exploit preconditions
- Attack surface: The authenticated vault key retrieval API endpoint
- Required access: Admin or owner privileges in any Helicone organization
- Trigger point: A request for a provider key identified by
providerKeyId
- Why exploitation is possible: The authorization path does not
consistently compare the requester's organization identifier with the
organization associated with the requested vault key
Why this happens
The underlying bug is an object-level authorization failure. The endpoint
retrieves and decrypts a provider credential based on an attacker-controlled
object identifier but does not enforce the required tenant ownership check
before returning the secret. This behavior maps to CWE-639: Authorization Bypass Through User-Controlled Key, where access to a resource is
determined by an identifier without adequately validating the caller's
authorization for that specific resource.
Potential impact
- An attacker may disclose another organization's plaintext OpenAI,
Anthropic, or Bedrock credentials
- Exposed provider keys could be used to incur unauthorized usage costs
- Attackers could access or manipulate upstream AI services according to
the permissions of the disclosed credentials
- Affected tenants could experience data exposure, service disruption, or
follow-on compromise
General mitigation guidance
Mitigation generally focuses on enforcing resource-level authorization
before retrieving or decrypting any secret.
Common defensive patterns include:
- Deriving the requester organization from the authenticated session rather
than trusting request parameters
- Enforcing an explicit organization-ownership check for every provider key
lookup
- Applying deny-by-default authorization policies to vault resources
- Separating authorization, retrieval, and decryption so unauthorized
records are never decrypted
- Limiting administrative privileges and using narrowly scoped service
identities
- Avoiding plaintext credential exposure when a reference, proxy, or
short-lived token can satisfy the integration requirement
How teams detect issues like this
Detection approaches can include:
- Static analysis and code review rules requiring tenant or resource-owner
checks before object retrieval
- API authorization tests that request valid resource identifiers across
organization boundaries
- Review of handlers that accept IDs for secrets, billing objects, files, or
other tenant-owned resources
- Audit-log monitoring for provider-key access where the requester and
resource organizations differ
- Policy enforcement requiring object-level authorization decisions before
secret decryption or response serialization

