/

CVE-2025-63822

Severity:

HIGH RISK

(8.1)

Incorrect Access Control (CWE-284) in SirenGPS Android

CVE-2025-63822

Deferred

Vulnerability type

Category:

Incorrect Access Control

CWE:

CWE-284

Impact:

Unauthorized access to and modification of personal information

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

SirenGPS Android Application 2.19.44 contains an authorization flaw that lets an authenticated attacker manipulate user identifier parameters to access another user's personal information. Depending on the affected API operation, the attacker may gain unauthorized read and write access because the server does not verify ownership or permission for the targeted account.

Affected context

The issue occurs in API requests used by the SirenGPS Android application when user identifiers are accepted from the client and are not consistently checked against the authenticated user's permissions. Deployments are at risk when backend authorization relies on client-supplied identifiers without enforcing object-level access decisions for each requested resource.

Exploit preconditions

  • Attack surface: SirenGPS backend API endpoints exposed to the Android application
  • Required access: An authenticated application account
  • Trigger point: An API request containing a user identifier for a target account
  • Why exploitation is possible: The API does not adequately verify that the authenticated requester is authorized to read or modify the referenced user's data

Why this happens

The underlying bug is an object-level authorization failure. The application trusts a client-controlled user identifier without enforcing a server-side relationship between the authenticated principal and the requested object. This behavior maps to CWE-284, where access to protected resources is not restricted according to the intended authorization policy.

Potential impact

  • An attacker may read personal information belonging to other users.
  • An attacker could modify unauthorized user data.
  • Account privacy and data integrity may be compromised.
  • The issue can enable broader enumeration of user records if similar endpoints share the same authorization weakness.

General mitigation guidance

Mitigation generally centers on enforcing authorization at the server for every

object-level operation.

Common defensive patterns include:

  • Deriving the effective user identity from the authenticated session rather than trusting client-supplied identifiers.
  • Applying deny-by-default, object-level authorization checks to every read and write request.
  • Centralizing permission decisions so API endpoints cannot omit required checks.
  • Validating resource ownership, tenant boundaries, and permitted roles before processing an operation.
  • Limiting service and database privileges so an authorization mistake exposes less data.
  • Returning uniform responses and applying rate limits to reduce unauthorized record enumeration.

How teams detect issues like this

Organizations can identify similar weaknesses through:

  • Static analysis and code review for authorization decisions based solely on request parameters.
  • Tests that substitute another user's identifier across every read and write endpoint.
  • API security testing for broken object-level authorization and cross-user access.
  • Review of database queries and service methods to confirm that authenticated identity and authorization predicates are enforced together.
  • Policy checks requiring explicit authorization middleware or centralized access-control services on protected routes.

Automated application-security review tools may help flag endpoints that use client-controlled identifiers without corresponding permission checks.

Sources

SourceLink
github.comgithub.com/Leoccc98/cve-reports/blob/main/advisories/CVE-2025-63822/README.md
play.google.complay.google.com/store/apps/details?id=com.sirengps.mobile

Frequently asked

questions

Yes, it may be exploitable through the application's API by an authenticated user who can submit requests containing manipulated user identifiers.

Yes. The described issue requires an attacker to have a valid authenticated application account, although the account may have fewer privileges than the targeted user.

Enforce server-side, object-level authorization for every operation and derive the requesting identity from trusted authentication context rather than client-supplied identifiers.

Combine centralized authorization, deny-by-default policies, cross-account API tests, least-privilege service access, and code-review checks for identifier-based resource lookups.

Find out what's already
exploitable in your codebase.