/

CVE-2026-33357

Severity:

HIGH RISK

(7.5)

Missing Authorization in Meari Device Status OpenAPI

CVE-2026-33357

Deferred

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Exposure of Sensitive Network Information

Severity:

HIGH RISK

(7.5)

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

A missing authorization check in the Meari cloud API endpoint GET /openapi/device/status allows retrieval of WAN IP information for arbitrary devices via client apps embedding com.meari.sdk.

If an attacker can invoke this call path with chosen device identifiers, they may obtain sensitive network metadata about devices they do not own or control.

Affected context

This vulnerability affects Meari-powered client applications that integrate the com.meari.sdk and rely on the Meari cloud backend, including (but not limited to):

  • CloudEdge 5.5.0 build 220
  • Arenti 1.8.1 build 220
  • Related white-label applications up to the 1.8.x series

The risk arises when these apps or automated clients can trigger GET /openapi/device/status against openapi-euce.mearicloud.com for device identifiers beyond the authenticated user's ownership, and the backend does not enforce per-device authorization.

Exploit preconditions

  • Attack surface: Internet-exposed cloud API (openapi-euce.mearicloud.com) reachable via mobile apps or scripted requests.
  • Required access: Network access to the API and the ability to authenticate or mimic a legitimate app session; knowledge or discovery of target device identifiers.
  • Trigger point: Invocation of GET /openapi/device/status through the integrated SDK or directly against the cloud API with a target device ID.
  • Why exploitation is possible: The server-side logic fails to verify that the requesting principal is authorized to access status information for the specified device, allowing enumeration or probing of arbitrary devices' WAN IP data.

Why this happens

The underlying issue is a missing authorization check on a sensitive cloud API endpoint that returns device status details, including WAN IP information.

Although clients authenticate to the Meari cloud, the backend does not correctly enforce ownership or access control for the device identifier supplied to GET /openapi/device/status.

This aligns with CWE-862: Missing Authorization, where the system authenticates the caller but omits fine-grained authorization on a protected resource, enabling cross-tenant or cross-account data exposure.

Potential impact

  • An attacker may obtain WAN IP addresses associated with arbitrary Meari-linked devices.
  • Attackers could build detailed mapping of device deployments across ISPs and geographic regions.
  • Exposure of WAN IPs can facilitate targeted network reconnaissance or follow-on attacks against device owners' home or office networks.
  • Aggregated data could support large-scale profiling of users and their connected devices.

General mitigation guidance

Effective mitigation focuses on enforcing strict, server-side authorization for all device-centric endpoints:

  • Implement per-device access control checks ensuring that the requesting user or client is explicitly associated with the device whose status is being queried.
  • Treat device identifiers and related metadata as sensitive multi-tenant resources, applying least-privilege principles for every API call.
  • Normalize access control into a central policy layer so that any new or existing endpoints that expose device status inherit consistent authorization rules.
  • Minimize exposure of WAN IP and similar network details; consider returning only the minimum necessary metadata for client functionality, and segregate potentially sensitive fields into more restricted APIs.
  • Design SDKs and client libraries to default to scoped, user-specific queries instead of accepting arbitrary device identifiers from untrusted input.

How teams detect issues like this

Identifying and monitoring for missing authorization issues typically involves:

  • Static analysis and code review: Look for API handlers that:
  • Accept device IDs or tenant-scoped identifiers as parameters.
  • Perform authentication but lack explicit ownership or role checks before returning data.
  • Use direct lookups by identifier without validating the relationship between the caller and the resource.
  • Access control testing: Use automated or manual security testing to attempt cross-account access:
  • Invoke device status endpoints with device IDs bound to different accounts.
  • Validate that authorization is consistently applied across all regions and white-label deployments.
  • Logging and anomaly detection: Instrument API gateways and backend services to log:
  • Requests querying multiple unrelated devices from a single account.
  • High-volume enumeration patterns that suggest probing for valid device IDs.

These signals can feed into SIEM or API security tooling for alerting and correlation.

  • Policy enforcement in CI/CD: Integrate security checks into pipelines to flag new endpoints exposing device or network metadata that do not declare and enforce an authorization policy.

Sources

SourceLink
github.comgithub.com/xn0tsa/nobody-puts-baby-in-a-corner
runzero.comrunzero.com/advisories/meari-openapi-device-status-idor-cve-2026-33357/

Frequently asked

questions

Yes. The affected endpoint is part of a cloud API reachable over the internet. Anyone who can reach openapi-euce.mearicloud.com and interact with the Meari SDK or API, subject to any authentication requirements, could attempt to exploit it.

Typically, the attacker needs some form of valid session or credentials to access the API, but the vulnerability stems from insufficient authorization on specific devices. A low-privileged or unrelated account may still be able to query information about devices it does not own if device-level checks are missing.

Centralize and enforce resource-level authorization for all device-related endpoints. For each request, the backend should verify that the caller is explicitly permitted to access the specified device and should avoid returning sensitive fields, like WAN IP, unless strictly necessary and policy-allowed.

Adopt a consistent access-control model where all APIs are designed around explicit ownership and roles, use a shared authorization service or middleware, and require security review for any endpoint that accepts user-supplied resource identifiers. Combine this with automated testing for cross-tenant access and least-privilege data exposure in your API design.

Find out what's already
exploitable in your codebase.