Summary
WeGIA contains an authorization flaw in its internal-record controller that allows an authenticated low-privileged user to access records belonging to other people. By supplying another record identifier, an attacker may read, modify, or delete sensitive personal, identity, address, medical, and family information.
Affected context
The issue occurs in WeGIA deployments where the internal-record controller accepts user-controlled id or idInterno values. Authorization middleware maps this controller to an empty resource set, and the permission check treats that state as unconditional access for authenticated users. The affected operations include record retrieval, alteration, and deletion, although exposure may depend on enabled routes and deployment configuration.
Exploit preconditions
- Attack surface: Authenticated web requests to internal-record controller methods
- Required access: A valid account with otherwise limited privileges
- Trigger point: Supplying an internal-record identifier to retrieval, update, or deletion operations
- Why exploitation is possible: The authorization layer does not verify ownership or permission for the referenced object, while the controller trusts the supplied identifier
Why this happens
The vulnerability results from missing object-level authorization combined with an authorization policy that interprets an empty resource mapping as permission for every authenticated user. Controller methods then use caller-supplied identifiers without confirming that the referenced record belongs to, or is accessible by, the caller. This maps primarily to CWE-639: Authorization Bypass Through User-Controlled Key and is also related to CWE-862: Missing Authorization.
Potential impact
- An attacker may read another person's personal or identity information
- Sensitive address, medical, and family data could be disclosed
- Unauthorized users could modify internal records
- Records could be deleted, causing data loss or operational disruption
- Privacy obligations and trust in the charitable institution could be affected
General mitigation guidance
Mitigation generally focuses on enforcing authorization at the object and operation level rather than relying on controller-wide resource mappings.
Common defensive patterns include:
- Checking ownership or explicitly granted access for every referenced record
- Applying deny-by-default behavior when a resource mapping is absent or empty
- Centralizing authorization checks so read, update, and delete paths use the same policy
- Validating identifiers as references to authorized objects, not merely as syntactically valid input
- Limiting accounts to the minimum privileges required for their duties
- Reducing sensitive data returned by endpoints to the minimum necessary
How teams detect issues like this
Organizations can look for this class of issue through:
- Static analysis rules identifying database lookups driven by request parameters without nearby authorization checks
- Code review signals such as controller methods accepting object identifiers before ownership validation
- Tests that exercise access to another user's records using authenticated accounts with different roles
- Policy checks that reject empty or undefined permission mappings when they result in allow behavior
- Runtime monitoring for repeated requests targeting sequential or unrelated record identifiers
Automated application-security testing and code-review tools can help identify missing object-level authorization when configured with representative roles and ownership relationships.

