/

CVE-2025-67274

Severity:

HIGH RISK

(7.5)

Information Exposure in continuous.software aangine Service

CVE-2025-67274

Analyzed

Vulnerability type

Category:

Information Exposure

CWE:

CWE-200

Impact:

Unauthorized Disclosure of Sensitive 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 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.

Sources

SourceLink
aangine.comaangine.com
continuous.softwarecontinuous.software/products
gist.github.comgist.github.com/c4m0uflag3/26fec868b764c4e7314ad246bab01c88

Frequently asked

questions

Yes. A remote attacker who can reach the affected endpoints over the network can attempt to retrieve exposed information. Whether this is possible from the public internet or only from internal networks depends on how the services are deployed and exposed.

Not necessarily. Some deployments may require authentication for these endpoints, while others might expose them with weak or no authentication. Even where authentication exists, insufficient authorization checks can allow low-privilege users to access data they should not see.

Implement strict, fine-grained authorization and data minimization for each endpoint. Responses should be based on dedicated, security-reviewed response models that include only non-sensitive fields appropriate to the caller's role and context.

Adopt a secure API design process that:

  • Treats all externally reachable endpoints as untrusted entry points.
  • Requires explicit, documented authorization rules for every operation.
  • Uses privacy and least-privilege reviews for response schemas.
  • Integrates automated checks in CI/CD to flag endpoints exposing internal entities or excessive fields.
Find out what's already
exploitable in your codebase.