Summary
OpenMetadata exposes JWTs used by a highly privileged ingestion-bot account through UI calls to /api/v1/ingestionPipelines, allowing read-only users to obtain tokens for services such as Glue, Redshift, and Postgres.
With these JWTs, low-privilege users can act as the ingestion bot, enabling destructive configuration changes in OpenMetadata and unauthorized access to sensitive metadata that should be restricted by roles and policies.
Affected context
This vulnerability occurs in OpenMetadata deployments where:
- The UI invokes
/api/v1/ingestionPipelinesto manage or inspect ingestion pipelines. - Responses include JWTs or equivalent credentials for the ingestion-bot account.
- Read-only users or other low-privilege roles can access these API responses via the UI or direct API calls.
The issue is most impactful when the ingestion-bot role has broad permissions over services like Glue, Redshift, and Postgres, including read access to sample data and write-level configuration capabilities.
Exploit preconditions
- Attack surface: OpenMetadata HTTP API endpoint
/api/v1/ingestionPipelines, typically exposed via the web UI. - Required access: Any authenticated read-only or otherwise low-privilege user able to view ingestion pipeline details or intercept associated API traffic.
- Trigger point: Viewing or querying ingestion pipeline resources through the UI or directly calling the endpoint, then extracting the exposed JWT from the API response.
- Why exploitation is possible: The system returns high-privilege ingestion-bot JWTs in contexts accessible to low-privilege users, violating the principle of least privilege and separating duty between viewing pipeline metadata and using privileged credentials.
Why this happens
At its core, this is a privilege management and access control design flaw consistent with CWE-269: Improper Privilege Management.
The application couples operational credentials (ingestion-bot JWTs) with user-facing API responses, failing to distinguish between:
- Data necessary for read-only inspection of ingestion pipelines, and
- Sensitive authentication tokens intended only for internal service-to-service operations.
This insecure pattern arises when high-privilege credentials are stored or serialized as part of user-accessible resources without redaction, token scoping, or role-based filtering, thereby enabling privilege escalation through credential reuse.
Potential impact
- Read-only users may impersonate the ingestion-bot account and perform actions with its elevated privileges.
- Unauthorized modification or deletion of ingestion pipelines and related configuration within OpenMetadata.
- Exposure of metadata and sample data from connected services (e.g., Glue, Redshift, Postgres) that should be hidden by policies.
- Potential disruption of ingestion processes, leading to integrity issues in metadata catalogs.
- Expanded attack surface if the ingestion-bot token is reused across multiple services or environments.
General mitigation guidance
Effective mitigation focuses on eliminating unnecessary credential exposure and enforcing strict privilege separation:
- Avoid returning JWTs, API keys, or other long-lived credentials in user-facing API responses; use server-side execution for privileged operations instead.
- Apply role-based redaction so that low-privilege users never see sensitive fields (tokens, secrets, connection strings) in ingestion pipeline definitions.
- Scope ingestion-bot tokens to the minimal required permissions, and use short-lived or service-bound tokens where possible.
- Implement a clear separation between configuration metadata visible in the UI and the underlying secret material used for ingestion.
- Centralize secret storage in a dedicated secrets manager and refer to secrets via references/identifiers rather than embedding them in pipeline objects.
How teams detect issues like this
Organizations can detect this class of issue by:
- Reviewing API schemas and response payloads for the presence of JWTs, API keys, or credentials in resources accessible to non-admin roles.
- Implementing automated tests or security checks that ensure sensitive fields are redacted or omitted for low-privilege users.
- Using static analysis or configuration scanning to flag code paths that serialize authentication tokens into API responses or front-end models.
- Conducting role-based access reviews, simulating low-privilege accounts and inspecting network traffic for exposed secrets.
- Enforcing security policies in CI/CD that disallow direct propagation of secret values into user-facing JSON or UI components.

