/

CVE-2025-70614

Severity:

HIGH RISK

(8.1)

Broken Access Control in OC Messaging / USSD Gateway

CVE-2025-70614

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-284

Impact:

Unauthorized Access to Sensitive SMS Content

Severity:

HIGH RISK

(8.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

OpenCode Systems OC Messaging / USSD Gateway OC Release 6.32.2 suffers from broken access control in its web-based control panel, where company or tenant identifiers are not properly enforced.

An authenticated low-privileged user can craft requests with arbitrary tenant identifiers and gain access to SMS messages belonging to other tenants, exposing sensitive communications and subscriber data.

Affected context

The vulnerability appears in the multi-tenant web-based control panel used to manage and view SMS messaging within OpenCode Systems OC Messaging / USSD Gateway.

It manifests when authorization checks rely on client-supplied company or tenant identifiers without consistently validating that the requesting user is actually entitled to access the specified tenant's resources.

Environments where tenants are logically separated but share the same backend and where session or role checks are not tightly bound to resource ownership are particularly exposed.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints of the OC Messaging / USSD Gateway web control panel.
  • Required access: Valid but low-privileged authenticated account within the application.
  • Trigger point: Manipulation of a company/tenant identifier parameter in requests that retrieve or search SMS messages.
  • Why exploitation is possible: The server trusts the tenant identifier supplied in the request and does not reliably enforce ownership or tenancy checks, allowing a user from one tenant to query or view SMS data belonging to another tenant.

Why this happens

This issue is a classic instance of broken access control as described by CWE-284, where the application fails to enforce authorization on a per-resource basis.

Instead of deriving tenant context solely from the authenticated session and internal mappings, the system accepts tenant or company identifiers from the client and uses them directly to scope database queries.

Because there is no strong server-side verification that the authenticated user is associated with the requested tenant, users can escalate their data access horizontally by substituting identifiers and retrieving SMS content outside their legitimate scope.

Potential impact

  • Exposure of SMS contents belonging to other tenants or customers.
  • Unauthorized access to sensitive user data, including OTPs, authentication codes, and confidential messages.
  • Violation of privacy regulations and contractual data separation requirements.
  • Facilitation of further attacks using intercepted messages (e.g., account takeover via stolen SMS codes).
  • Reputational damage due to cross-tenant data leaks in multi-tenant environments.

General mitigation guidance

Mitigation should focus on enforcing strict server-side authorization that does not rely on client-supplied tenant identifiers.

Recommended defensive patterns include:

  • Derive tenant and company context exclusively from the authenticated session or token, ignoring any tenant identifiers in user-controlled input for authorization decisions.
  • Implement resource-level access checks that verify ownership of each SMS record against the caller's effective tenant and role before returning data.
  • Use a centralized authorization layer or policy engine to consistently apply tenancy and role constraints across all endpoints.
  • Apply the principle of least privilege to application roles, granting only the minimal set of permissions required for each user type.
  • Design multi-tenant data models that enforce tenant boundaries at the query layer (e.g., mandatory tenant filters bound to session context).

How teams detect issues like this

Effective detection approaches can combine design-time and runtime analysis:

  • Static analysis: Look for controller or service methods that filter data by tenant or company identifiers passed directly from HTTP parameters or JSON bodies, especially where there is no preceding check tying the tenant to the authenticated user.
  • Code review signals: Flag any use of request-supplied tenant IDs in database queries, missing ownership checks before returning SMS or message entities, and authorization logic duplicated or implemented ad hoc across endpoints.
  • Security testing: Perform multi-tenant penetration tests and API fuzzing to verify that changing tenant or company identifier parameters does not expose other tenants' data.
  • Runtime monitoring: Add logging for access-control failures and suspicious cross-tenant access patterns, and feed these into alerting or anomaly-detection systems.

Sources

SourceLink
gist.github.comgist.github.com/whiteman0007/e02b8cfd6c67ff1eaaf54fba041582a1

Frequently asked

questions

The impact is typically cross-tenant within the same deployment. Any user with a valid low-privilege account may be able to access SMS messages belonging to other tenants, depending on how widely tenant identifiers are reused across endpoints.

No. The vulnerability can be exploited by low-privileged authenticated users, as long as they can reach endpoints that accept company or tenant identifiers and return SMS-related data.

Remove reliance on client-supplied tenant identifiers for authorization and consistently derive tenant scope from the authenticated session or token. Apply centralized, server-side checks that verify resource ownership (e.g., each SMS belongs to the caller's tenant) before returning any data.

Adopt a strict, design-time access-control model for multi-tenant systems: enforce tenant isolation in the data access layer, use standardized authorization middleware or policies, avoid passing security-critical identifiers from the client, and validate access-control behavior through regular code reviews and multi-tenant security testing.

Find out what's already
exploitable in your codebase.