HIGH 7.6

CVE-2026-56231 Capgo BOLA Vulnerability: Cross-Tenant Build Sabotage

Capgo versions before 12.128.2 contain a critical authorization flaw that allows authenticated users to hijack build jobs belonging to other customers. If you have permission to build apps in your own tenant, an attacker can use that legitimate access to start or cancel build jobs owned by completely different organizations by manipulating the job identifier. This could disrupt competitors' deployments, waste their compute resources, and potentially inflate their bills—all while appearing to come from the attacker's authorized account.

Source data · NVD / CISA · public domain

CVSS
3.1 · 7.6 HIGH · CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:H
Weaknesses (CWE)
CWE-285
Affected products
0 configuration(s)
Published / Modified
2026-06-24 / 2026-06-25

NVD description (verbatim)

Capgo before 12.128.2 contains a broken object level authorization (BOLA) vulnerability in the POST /build/start/:jobId and POST /build/cancel/:jobId endpoints. The handlers authorize the request based only on the attacker-controlled app_id supplied in the request body and never verify that the jobId in the URL belongs to that app_id (or the same tenant/org) before issuing privileged builder commands with the server-held builder API key. An authenticated user with the app.build_native permission for any app they control can start or cancel arbitrary builder jobs belonging to other tenants by supplying a victim jobId, resulting in cross-tenant build sabotage (denial of service), unauthorized compute actions, and potential billing impact.

3 reference(s) · View on NVD →

SEC.co analysis · AI-assisted, reviewed against source

Technical summary

The vulnerability is a broken object-level authorization (BOLA) flaw in the POST /build/start/:jobId and POST /build/cancel/:jobId endpoints. The application authorizes requests by checking only the app_id parameter supplied in the request body, but fails to validate that the jobId referenced in the URL actually belongs to that app_id or exists within the same tenant/organization. An authenticated attacker with the app.build_native permission can craft requests specifying a valid jobId from a victim organization while supplying their own app_id, causing the backend to execute privileged builder commands (issued via the server's stored builder API key) against the wrong tenant's build infrastructure.

Business impact

Organizations using Capgo for mobile app builds face three material risks: (1) Operational disruption—attackers can cancel critical builds in progress, delaying production releases; (2) Resource abuse—unauthorized build jobs consume cloud compute and storage, inflating operational costs; (3) Reputational and competitive harm—malicious actors could sabotage competitor builds or sabotage their own organization's builds to frame rivals. Multi-tenant SaaS providers are especially vulnerable because a single compromised user account with build permissions can impact multiple customer organizations.

Affected systems

Capgo before version 12.128.2 is affected. The vulnerability requires the attacker to possess the app.build_native permission within their own tenant, meaning internal developers or third-party build users with that role are the primary threat vectors. Cross-tenant impact means all Capgo customers sharing the same instance are at risk if any one of them has a user with build permissions who is compromised or malicious.

Exploitability

Exploitability is relatively straightforward for insiders. The attack requires authentication (a valid Capgo user account with app.build_native permission) and knowledge of a target jobId, but jobIds may be enumerable or discoverable through standard reconnaissance. No user interaction is required, and the network attack surface is direct—no client-side bypasses or complex chaining needed. The barrier to exploitation is low-to-moderate for any authenticated user willing to probe other tenants' job identifiers.

Remediation

Upgrade to Capgo version 12.128.2 or later. This version implements proper object-level authorization checks ensuring that the jobId in the URL is validated to belong to the app_id and tenant context of the authenticated user before executing any builder commands. Organizations unable to upgrade immediately should restrict the app.build_native permission to trusted administrators and monitor build logs for unexpected job cancellations or starts from unusual API patterns.

Patch guidance

Apply Capgo 12.128.2 or later as soon as feasible. This is a critical cross-tenant isolation issue and should be prioritized ahead of most other updates. Verify the patch release notes confirm the authorization checks have been implemented for both /build/start and /build/cancel endpoints. If you maintain a staging environment, test the upgrade there first to ensure no build workflows are disrupted, then promote to production. Post-patch, review your user permissions and consider auditing recent build activity for any anomalies.

Detection guidance

Examine Capgo API logs and audit trails for the following indicators: (1) POST requests to /build/start or /build/cancel with jobIds that do not match the requesting user's organization or app; (2) Rapid or sequential build cancellations across multiple distinct apps or tenants; (3) Build job activity from users or service accounts that do not typically interact with those apps; (4) Unusual patterns in the app_id parameter in request bodies that differ from the authenticated user's expected scope. If available, correlate build log anomalies with user login times and IP addresses to identify potential account compromise.

Why prioritize this

This merits immediate attention due to its cross-tenant isolation breach, the authenticated-but-widespread attack surface (any user with build permissions poses a risk), and the tangible operational and financial impact. Unlike many BOLA flaws that affect a single user's personal data, this one directly compromises infrastructure availability and cost control across multiple customers. Combined with the HIGH CVSS score and the relative simplicity of exploitation, it should be treated as a critical priority.

Risk score, explained

The CVSS 3.1 score of 7.6 (HIGH) reflects: Attack Vector Network (broad exposure via standard API endpoints), Attack Complexity Low (no special conditions required), Privileges Required (authenticated users only, a common but significant gate), Scope Unchanged (impact confined to one security domain), and impact on Confidentiality (partial—some app metadata may be exposed), Integrity (partial—job state is modified), and Availability (high—builds can be denied). The cross-tenant nature and lack of CVSS scope escalation may keep the numeric score from 'CRITICAL', but the real-world harm of infrastructure sabotage and multi-customer impact elevates the practical risk significantly.

Frequently asked questions

If I only have read-only access to Capgo, am I at risk?

No. The vulnerability requires the app.build_native permission, which grants the ability to start and cancel builds. Read-only users cannot exploit this flaw. However, they could be targets if an attacker obtains one of their build job IDs and uses a privileged account to interfere with it.

Can this vulnerability be exploited without knowing a specific jobId?

Possibly. If jobIds are sequential, predictable, or exposed in logs or UI elements, an attacker could enumerate them. However, the attacker must have at least one valid jobId from a target organization. Capgo should implement jobId unpredictability as a defense-in-depth measure in addition to the authorization fix.

What should I do if I discover suspicious build activity in my logs after updating?

Review the timestamps, usernames, and IP addresses associated with unexpected build starts or cancellations. Cross-reference them with your user access logs and VPN/proxy records to identify compromised accounts. Reset credentials for any suspicious users and consider rotating API keys used by build systems. Escalate to your security team and contact Capgo support if you suspect a breach.

Does this vulnerability affect our billing, or is it just a build delay issue?

Both. An attacker can start unauthorized builds, consuming compute resources and running up charges against a victim's account. They can also cancel active builds, causing delays and repeated billing if your pricing model charges per build attempt. The financial impact depends on your Capgo pricing plan and the attacker's persistence.

This analysis is provided for informational purposes and does not constitute professional security advice. Organizations should verify all technical details, patch availability, and compatibility against their own environments and Capgo's official advisories before taking remedial action. SEC.co makes no warranty regarding the completeness or accuracy of this intelligence beyond the source data provided. Consult your security team and Capgo support for guidance specific to your deployment. Source: NVD (public-domain), retrieved 2026-07-30. Analysis generated by SEC.co (claude-haiku-4-5).