Summary
A set of service endpoints in continuous.software aangine v.2025.2 expose sensitive information through the excel-integration-service template download, integration-persistence-service job listing, and portfolio-item-service data retrieval modules.
A remote attacker who can reach these endpoints may obtain data that should not be externally visible, depending on how authentication and authorization are configured in a given deployment.
Affected context
This vulnerability affects deployments of continuous.software aangine v.2025.2 where the following services are reachable over the network:
- excel-integration-service template download module
- integration-persistence-service job listing module
- portfolio-item-service data retrieval module
The issue typically appears when these endpoints return verbose or overly broad datasets without adequately scoping or filtering the response based on the caller's identity, role, or intended use. It is most relevant in environments where these services are exposed beyond strictly controlled internal networks or where access controls are loosely enforced.
Exploit preconditions
- Attack surface: HTTP(S) endpoints exposed by:
- excel-integration-service (template download)
- integration-persistence-service (job listing)
- portfolio-item-service (data retrieval)
- Required access: Network access to the affected services; exploitation may or may not require authentication depending on deployment configuration.
- Trigger point: Sending crafted or even standard requests to the affected endpoints to retrieve templates, job metadata, or portfolio data.
- Why exploitation is possible: The endpoints return sensitive or overly detailed information without sufficient access control, response filtering, or data minimization, allowing attackers to see data beyond what they are legitimately authorized to access.
Why this happens
The underlying issue aligns with CWE-200: Exposure of Sensitive Information to an Unauthorized Actor.
At a design and implementation level, the services appear to:
- Expose business objects (templates, jobs, portfolio items) directly through API responses.
- Lack strict authorization checks and context-aware filtering before returning results.
- Potentially reuse internal data models or queries without applying least-privilege principles to the fields and records returned.
This pattern results in endpoints that leak more information than necessary, making it possible for remote callers to infer or directly obtain sensitive data that should remain restricted.
Potential impact
- An attacker may obtain internal portfolio or project data not intended for external visibility.
- An attacker may list or enumerate jobs and integration configurations, aiding further reconnaissance.
- An attacker could access sensitive template content that reveals business logic, schema, or proprietary structures.
- Exposed metadata and records can facilitate targeted attacks, social engineering, or data correlation against other systems.
- Compliance-related data exposure (e.g., customer or operational information) can lead to regulatory impact depending on the environment.
General mitigation guidance
Mitigation typically focuses on reducing information exposure at the API design and authorization layers:
- Apply strict authorization checks for every endpoint, evaluating whether the caller is allowed to access specific records and fields.
- Adopt data minimization: design responses so they return only the data strictly required for the client's use case, avoiding internal identifiers, configuration details, or unnecessary fields.
- Introduce role- and tenant-aware filtering, ensuring responses are scoped to the user, project, or organization context associated with the caller.
- Separate internal models from external contracts (e.g., DTOs or view models) so that sensitive internal attributes are never serialized by default.
- Implement default-deny policies for new fields or endpoints, requiring explicit review before exposing additional data.
- Use consistent error handling and avoid returning verbose error messages or stack traces that might leak additional information.
How teams detect issues like this
Effective detection often combines code-centric and behavior-centric approaches:
- Static analysis and code review:
- Flag controllers or handlers that expose entity objects directly without mapping to restricted response models.
- Identify endpoints lacking explicit authorization checks or relying solely on coarse-grained access control.
- Review query building and filtering logic to confirm that tenant, ownership, and role constraints are enforced.
- API contract and schema review:
- Inspect OpenAPI/Swagger or similar specs for endpoints returning broad or unfiltered collections and sensitive fields.
- Enforce policies that require security review for endpoints marked as public or externally accessible.
- Runtime monitoring and logging:
- Monitor for unusually large or frequent data retrieval from these services, especially from unknown or low-trust origins.
- Use web application firewalls or API gateways with rules to detect anomalous enumeration patterns.
- Automated security testing tools can be configured to probe these endpoints for overexposed fields, missing access control, and excessive data in responses.

