Siyang Wu

A remote path traversal issue exists in the `validate safe path()` function within the `src/mcp atlassian/utils/io.py` file. This occurs when the `path` argument is manipulated, allowing an attacker to access files or directories outside the intended folder.

A use after free issue exists in the Autofill component. A remote attacker could use social engineering to lure a user to a crafted HTML page, potentially leading to arbitrary code execution outside the sandbox. Use after free is a memory corruption flaw that occurs when an application continues to use a pointer after it has been freed.

Missing authorization in Input allows a remote attacker to obtain sensitive information through the use of a crafted HTML page.

Missing authorization in DevTools allows a remote attacker to bypass the web origin policy through the use of a crafted Chrome extension, typically requiring social engineering to execute.

An issue exists that allows for PHP Object Injection, a technique where an attacker can manipulate serialized objects to execute arbitrary code or interfere with application logic.

An issue exists where the software allows Local File Inclusion, which occurs when an application includes a file without properly validating the input. Authenticated attackers with contributor-level access or higher can include and execute arbitrary files on the server. This can lead to the execution of PHP code, bypassing of access controls, or the retrieval of sensitive data, particularly when images or other safe file types are uploaded and then included.

Improper input validation occurs in the `parse section()` and ` decode name()` functions, where resource record lengths are not checked against the received message. An attacker who controls or spoofs a queried nameserver can send truncated record headers or RDATA, causing uncaught Lua exceptions in `resolver:query()`. This results in aborted requests and the failure of name resolution.

The Docker API server contains an issue where authenticated API clients can provide unbounded regular expressions in the '/crawl' endpoint request bodies. This can lead to catastrophic backtracking—a condition where a regular expression engine takes an exponential amount of time to process a specific input—when using `RegexExtractionStrategy.custom`, `RegexChunking.patterns`, or the regex fields within `JsonCss`, `JsonXPath`, and `JsonLxml` schemas against a specially crafted page. This can result in the entire server freezing, including the '/health' endpoint.

An HTML injection issue exists in the `CreateConversationalHeader` function within `pkg/notifications/mail.go`. The system fails to properly sanitize display names, task titles, and project titles before interpolating them into email anchors. Authenticated users can exploit this by crafting specific titles or display names to close the anchor tag and inject phishing links into task-comment and task-mention notification emails sent to project members.

Improper authorization exists in the handler for custom URL schemes within the Window Open Handler component. A remote attacker can exploit this by manipulating the `url` argument passed to the `shell.openExternal()` function located in the `src/mainWindow.js` file.

A flaw in the TLS Handler component within the `index.php` file allows for improper certificate validation. This issue can be exploited remotely, although it requires a high level of complexity and is considered difficult to execute.

An issue exists in the TLS Handler component within the `lib/main.dart` library. Specifically, the `MyHttpOverrides()` function allows for improper certificate validation, which could be exploited remotely. This attack is characterized by high complexity and is difficult to execute.

A remote issue exists in the HTTP Client component within the ` curl()` function of the web.php file. This flaw leads to improper certificate validation, which occurs when the system fails to correctly verify the authenticity of a digital certificate. Exploitation of this issue is considered highly complex and difficult.

A flaw in the Remote Control Server component, specifically within a function in the `database.ts` file, allows for remote attacks. By manipulating the `remoteEnabled` argument, an attacker can bypass authentication.

An unauthenticated server-side request forgery (SSRF) exists in the '/downloadfile/:docid' endpoint. This occurs when JWT verification is disabled in the default configuration, allowing remote attackers to bypass the private-IP request-filtering-agent by exploiting the `isInJwtToken` flag. By submitting a crafted request body containing an internal or loopback URL, the server treats the request as a DIRECT request, skipping private-address filtering and causing the server to fetch and proxy back arbitrary private-network and cloud metadata content.

The application uses a fixed, publicly documented AES-128-ECB key to decrypt response bodies from the '/eapi/' and '/xeapi/' API endpoints. Because there is no integrity credential, an attacker capable of intercepting or originating server responses can create valid ciphertext using PKCS#7 padding. This allows the client to accept forged API responses, which can be used as a step toward further exploitation, such as accessing the `os.navigateExternal` bridge.

A remote code execution issue exists in the renderer-process IPC bridge `os.navigateExternal`, which passes caller-supplied URLs to the `ShellExecuteW()` function without validating the URL scheme. An attacker can inject content into the renderer by forging the '/pc/upgrade/get' API endpoint response using a known AES key over an unvalidated TLS connection. This allows the attacker to invoke `os.navigateExternal` with a `file://` URL via an `img onerror` payload to execute arbitrary local binaries under the account of the logged-in user.

The application fails to validate the server certificate chain, verify the hostname, or consult the Windows certificate trust store during TLS handshakes. This allows a network-adjacent attacker to perform a man-in-the-middle attack using a rogue certificate authority to intercept and decrypt HTTPS traffic. By doing so, an attacker can capture the `MUSIC U` session credential used in authenticated API requests and modify server responses in transit, which can lead to account takeover and transport-layer response forgery.

TLS certificate verification is disabled in the `parseKubeconfig()` and `parseKubeconfigFile()` functions when a kubeconfig lacks `certificate-authority-data`, which causes the system to ignore `insecure-skip-tls-verify`. This allows on-path attackers to impersonate the Kubernetes API server to capture Basic credentials or Bearer tokens and tamper with REST API or WebSocket traffic.

Path traversal exists in theme IPC handlers, allowing scripts running in the Discord origin, such as through Cross-Site Scripting (XSS), to escape the themes directory. This occurs due to unvalidated theme IDs. Attackers can abuse the `themes.folder`, `themes.uninstall`, and `themes.install` handlers to launch local executables, recursively delete directories, and write files outside the intended themes directory.