Kodareef5

Server-side request forgery (SSRF) occurs in the Cheerio, Playwright, and Puppeteer document loader nodes, allowing the bypass of SSRF protection. This enables attackers to provide arbitrary URLs to retrieve cloud metadata, internal services, and private network resources, with the response content returned as document text.

Envoy fails to properly handle scoped IPv6 addresses when using `Utility::copyInternetAddressAndPort` and QUIC client-address paths. The process reconstructs these addresses via `addressAsString` and `Ipv6Instance`, resulting in a string containing a percent scope identifier that `inet pton` cannot parse. This leads to an exception or process abort. The issue can be triggered by kernel-provided scoped IPv6 destinations in ORIGINAL DST transparent-proxy deployments or through affected QUIC connection paths.

SSO configuration API endpoints are exposed on the same public routing boundary as the SSO login and callback endpoints, allowing SSO, OIDC, and SAML management operations to be accessed without administrator authorization. This allows unauthorized or low-privileged users to inspect or modify the authentication configuration, potentially leading to account takeover or privilege escalation. Additionally, the SSO connectivity-test function can be used as a server-side request forgery (SSRF) primitive—a technique where an attacker induces the server to make requests to an unintended location. Furthermore, the user list API returns user objects without consistently removing authentication-related fields.

An authenticated MQTT client can subscribe to the internal `$MQTT.deliver.pubrel` subject family. This action allows the client to bypass configured subscribe permissions and expose MQTT QoS2 protocol metadata for sessions within the account. QoS2 (Quality of Service level 2) is a protocol mechanism that ensures a message is delivered exactly once.

Message trace destination checks are not consistently applied to messages arriving through leafnode connections. This allows a leafnode operator to send trace events to subjects that are normally restricted and utilize trace-only behavior to block the standard delivery or storage of affected messages.

An unauthenticated peer with network access to a leafnode listener with compression enabled can cause the server to crash. This occurs during the pre-authentication leafnode handshake when repeated leafnode INFO protocol messages are sent before the authentication and account setup processes are completed.

Coolify is an open-source and self-hostable tool for managing servers, applications, and databases. An authenticated user can execute commands on managed servers when a resource is deleted because the `LocalPersistentVolume.name` field is interpolated directly into docker volume shell commands without shell argument escaping. This allows the injection of shell metacharacters into the storage name.

The SAML source response processor `ResponseProcessor.parse()` fails to validate the Conditions element on assertions. Specifically, `NotBefore`, `NotOnOrAfter`, and `AudienceRestriction` are ignored, which enables the replay of expired assertions and the acceptance of assertions intended for different service providers.

In the `ngclient` implementation, the `DelegatedRole. is target in pathpattern()` function in `tuf/api/ payload.py` uses `fnmatch.fnmatch` to verify if a target path is authorized by a delegation glob pattern. On Windows, `fnmatch.fnmatch` applies `os.path.normcase`, which converts strings to lowercase, making the path authorization case-insensitive. This behavior deviates from the TUF specification and differs from Linux and macOS. If a repository contains path-based delegations that differ only by case and an attacker-controlled role is processed before the legitimate role, a Windows client may accept an unauthorized target provided by the attacker for a requested path.

A path traversal issue exists due to improper validation of submodule names and a trust inheritance flaw. The `name()` function in `gix-validate` only checks the first occurrence of `..`, allowing crafted names like `a..b/../../../.git/` to bypass the check. Furthermore, this validation is not invoked in production code paths. In `Submodule::open()`, the parent repository's `git dir trust` (set to `Trust::Full`) is cloned, which causes the system to skip ownership verification. An attacker can exploit this by crafting a malicious `.gitmodules` file, leading a tool built on gitoxide to read arbitrary git repository configurations, including embedded credentials, while bypassing safe-directory protections.

The issue involves unchecked array indexing during delta application and uncapped memory allocation triggered by attacker-controlled size headers in the `gix-pack` module. An attacker can send specially crafted pack data during clone or fetch operations to cause the process to panic or be killed due to out-of-memory conditions.

When run against deployments with WireGuard encryption enabled, the output of the `cilium-bugtool` debugging tool can contain sensitive data. Specifically, the WireGuard private key `cilium wg0.key`, used for node-to-node encrypted communication, may be exposed. This tool is typically invoked manually or during the gathering of sysdumps via the `cilium sysdump` command.

A timing side-channel issue exists in the BasicAuth middleware. A variable meant to provide a constant-time fallback secret consistently resolves to an empty string, which causes the constant-time comparison to short-circuit quickly instead of completing a full bcrypt evaluation. This creates a timing oracle, allowing an attacker to enumerate valid usernames by measuring differences in authentication response times.

The Cookie Rewriting feature is susceptible to Lua code injection. An attacker with RBAC permissions to create or modify HTTPProxy resources can provide malicious values in the `spec.routes[].cookieRewritePolicies[].pathRewrite.value` or `spec.routes[].services[].cookieRewritePolicies[].pathRewrite.value` variables, leading to arbitrary code execution in the Envoy proxy. This occurs because user-controlled values are interpolated into Lua source code using Go text/template without sufficient sanitization. While the injected code executes only on the attacker's own route, it can be used to read Envoy xDS client credentials from the filesystem—potentially exposing TLS certificates and private keys of other tenants—or cause a denial of service for other tenants sharing the Envoy instance.

A validation bypass in the VolumeMount path restriction allows mounting volumes under restricted '/tekton/' internal paths by using '..' path traversal components. The restriction check uses the `strings.HasPrefix` function without applying `filepath.Clean`, meaning a path such as '/tekton/home/../results' passes validation but resolves to '/tekton/results' at runtime. This occurs because '/tekton/home' is an allowed prefix, allowing the traversal to bypass the check. This issue exists in the `container validation.go` and `task validation.go` files. An authenticated user with Task or TaskRun creation permissions could exploit this to write fake task results, read or modify step scripts before execution, or interfere with entrypoint coordination state.

The git resolver fails to validate the `revision` parameter, which is passed directly as a positional argument to the `git fetch` command. This allows an attacker to inject arbitrary flags, such as `--upload-pack=<binary>`. Additionally, the `validateRepoURL` function permits URLs starting with `/`, allowing local filesystem paths. A tenant capable of submitting `ResolutionRequest` objects can combine these behaviors to execute arbitrary binaries on the resolver pod. Because the `tekton-pipelines-resolvers` ServiceAccount possesses cluster-wide `get`, `list`, and `watch` permissions on all Secrets, this can lead to full cluster-wide secret exfiltration.

Manipulating query parameters on Control Panel and REST API endpoints, or arguments in GraphQL queries, can lead to the loss of content, assets, and user accounts. Exploitation via the Control Panel requires authentication with minimal permissions, such as the "view entries" permission to delete entries or the "view users" permission to delete users. Exploits targeting the REST and GraphQL APIs do not require permissions, but these APIs are not enabled by default; they must be explicitly enabled without authentication and with specific resources accessible to be exploited.

An authorization bypass exists within the `email domain` enforcement option. An attacker can authenticate using a malformed email claim, such as `attacker@evil.com@company.com`, to satisfy an allowed domain check for `company.com`. This issue specifically affects deployments relying on `email domain` restrictions that accept email claim values from identity providers or claim mappings that do not strictly enforce standard email syntax. The risk is primarily present in self-hosted or custom OIDC environments and federated setups where unexpected claim values can reach the proxy.

An issue exists in the conditions filter webhook within `libs/application-generic/src/usecases/conditions-filter/conditions-filter.usecase.ts` where the user-configured `child.webhookUrl` is passed directly to `axios.post()` without undergoing SSRF validation via the `validateUrlSsrf()` function. This allows an attacker to trigger a POST request to private or link-local services, such as AWS IMDSv1, during workflow condition evaluation. The resulting response data is stored in execution details and can be retrieved through the 'GET /execution-details' endpoint, potentially disclosing internal service data or credentials from POST-capable metadata services. SSRF (Server-Side Request Forgery) is a vulnerability where a server is tricked into making requests to an unintended location.

The v2 template engine in `runtime/template/v2/template.go` removes `env` and `expandenv` from `TxtFuncMap()` but leaves the `getHostByName()` function accessible to user-controlled templates. Since the controller executes templates within its own process, an attacker capable of creating or updating templated ExternalSecret resources can trigger controller-side DNS lookups using secret-derived values. This enables a DNS exfiltration primitive, allowing secret material to be leaked via DNS queries without requiring direct outbound network access from the attacker's workload. This results in a confidentiality issue in environments where lower-trust users can author these resources and the controller has DNS resolution capabilities.