Credential exposure in Cisco RoomOS allows an authenticated low-privilege local user to capture user login credentials by enabling a specific debug logging level and collecting the resulting system logs. The flaw (CWE-532) spans a wide version range from RoomOS 10.x through 26.x across Cisco's entire room collaboration device portfolio. No public exploit code has been identified and this CVE does not appear in the CISA KEV catalog at time of analysis, but the High confidentiality impact - plaintext credential disclosure - warrants prioritized patching on any device with non-administrative local accounts.
Insecure Direct Object Reference (IDOR) in Apache Answer through version 2.0.1 allows any authenticated user to delete uploaded files belonging to other users by supplying arbitrary file URLs to the avatar-cleanup endpoint. The root cause is a missing ownership check in the file-deletion logic (CWE-639), meaning the application accepts a user-controlled file URL and acts on it without verifying the requesting user has authority over that resource. No public exploit has been identified at time of analysis, but the attack requires only a valid account, making it low-friction once an attacker has registered or compromised any user.
Signature forgery in Documenso's V1 sequential-signing workflow allows an authenticated ASSISTANT-role recipient to complete signature fields owned by any co-recipient with an equal or later signing order, bypassing per-field ownership authorization entirely. The flaw resides in sign-field-with-token.ts, which upserts Signature records against the target field's recipientId without validating field type or ownership - a guard that Documenso's own V2 path (sign-envelope-field.ts) explicitly enforces and that the project's test suite comments confirm is absent from the V1 path. No public exploit code has been identified at time of analysis, but exploitation requires only low-privilege authenticated access as a named ASSISTANT recipient within a targeted document envelope.
Resource exhaustion in Apache Qpid Proton-J through 0.34.1 allows authenticated AMQP clients to trigger unbounded server-side resource consumption by sending a delivery composed of an arbitrarily large number of transfer frames - a limit the library fails to enforce. The root cause (CWE-770) is an absent cap on per-delivery transfer frame counts during message ingestion, not a memory corruption or code execution class flaw. No public exploit has been identified at time of analysis, and the vulnerability is not listed in CISA KEV; the primary risk is targeted denial of service against messaging infrastructure by any authenticated AMQP peer.
Denial of service in Apache Qpid Proton-J through 0.34.1 allows authenticated AMQP clients to exhaust server CPU by sending a crafted disposition frame carrying large or illegal delivery ranges. The library's naive range handling iterates without bounds validation, causing unbounded CPU consumption that can starve legitimate connections. No public exploit identified at time of analysis; vendor-released fix is available in version 0.35.0.
Denial of service in Apache Qpid Broker-J through 10.0.1 allows authenticated session participants to exhaust broker resources by deliberately exceeding the AMQP session flow control incoming window. The broker fails to enforce adequate limits on resource allocation when a session window is overflowed, enabling a malicious but authenticated client to destabilize or crash the broker. No public exploit code exists at time of analysis, and no confirmed active exploitation has been reported.
Denial of service in Apache Qpid Proton-J through 0.34.1 allows authenticated remote attackers to render the messaging endpoint unresponsive by deliberately exceeding the AMQP session flow control incoming window, triggering unbounded resource consumption. The root cause is CWE-770 - insufficient throttling of resource allocation - a well-understood class of flaw in protocol session management. No active exploitation has been confirmed and no public exploit code is known at time of analysis; the vendor has released a fix in version 0.35.0.
Case-insensitivity handling inconsistency in Jenkins 2.575 and earlier allows attackers to impersonate existing users or inherit their permissions by registering accounts with Unicode characters that case-insensitively match existing usernames. Jenkins generates canonical user IDs via lowercasing but performs comparisons using Java's `String#equalsIgnoreCase`, which follows Unicode case-folding semantics - for example, the Turkish dotless 'ı' is treated as equal to 'i' during comparison but produces a different canonical ID when lowercased. Exploitation is constrained to deployments using external security realms that permit non-ASCII characters in usernames; no public exploit has been identified at time of analysis.
Denial of service in HPE Integrated Lights-Out 6 (iLO 6) firmware prior to v1.78 allows an unauthenticated attacker on an adjacent network segment to render the management interface unavailable. The impact is limited to availability (A:H) with no confidentiality or integrity compromise, but disrupting iLO can blind administrators to server state and block out-of-band recovery operations during incidents. No public exploit or active exploitation has been identified at time of analysis; HPE has released v1.78 as the fix.
Improper authorization in Apache Answer through version 2.0.1 allows any authenticated user to reject arbitrary pending edit-revisions without holding review permissions. The missing authorization check on the reject operation means content moderation controls are effectively bypassed by ordinary users, enabling disruption of the peer-review workflow. No public exploit code exists and this vulnerability is not listed in the CISA KEV catalog at time of analysis.
CVE-2026-70439 is part of the Jenkins multi-CVE security advisory published August 5, 2026, covering vulnerabilities across Jenkins core and multiple plugins. The advisory batch includes critical issues such as a Remoting deserialization filter bypass enabling controller code execution (CVE-2026-70426), arbitrary file write via crafted tar archives (CVE-2026-70427), and path traversal enabling script deployment (CVE-2026-70428). The specific technical details for CVE-2026-70439 are not present in the available data - the oss-security disclosure is truncated and covers only CVE-2026-70426 through the beginning of CVE-2026-70435 before cutting off. No public exploit or CISA KEV listing is confirmed for CVE-2026-70439 at time of analysis.
Unrestricted brute-force against changedetection.io's /login endpoint allows a remote unauthenticated attacker to systematically guess the single shared application password with no throttling, lockout, or attempt counter to impede automated attacks. Because the entire application is protected by one shared credential with no per-user account model, a successful guess grants full administrative control - including the ability to view and regenerate the API token and access all monitored URL configurations. No public exploit code or CISA KEV listing has been identified at time of analysis, but the attack is trivially automatable given the network-accessible endpoint, low complexity (CVSS AC:L), and complete absence of brute-force controls confirmed by requirements.txt inspection.
Cleartext credential exposure in Cisco Catalyst SD-WAN Manager's web-based management interface allows an authenticated low-privileged remote attacker to read sensitive authentication material from system logs. The root cause is an incomplete encryption allowlist: specific template types are excluded from the encryption policy, resulting in sensitive values being written to logs in cleartext - accessible both on the local system and on any configured remote logging server. No public exploit code has been identified and this vulnerability is not listed in CISA KEV, but successful exploitation directly enables credential theft that can cascade into broader SD-WAN infrastructure compromise.
Header injection in openshift/oauth-proxy allows unauthenticated network attackers to impersonate arbitrary users on upstream applications by exploiting authentication-bypass paths. When skip-auth-regex rules are configured, the proxy forwards client-controlled identity headers (X-Forwarded-User, X-Forwarded-Email, X-Forwarded-Access-Token) to upstream services without stripping them, enabling forged identity claims. Affecting Red Hat OpenShift Container Platform 4, this vulnerability is classified under CWE-345 (Insufficient Verification of Data Authenticity) with a CVSS 6.5 base score; no public exploit code or CISA KEV listing has been identified at time of analysis.
Cross-site request forgery in OpenBK7231T firmware's /cfg_wifi_set endpoint allows a remote attacker to simultaneously hijack a device's WiFi credentials and silently disable its web admin password protection via a single malicious HTTP GET request triggered in an authenticated admin's browser. The vulnerability is compounded by a logic flaw: omitting the `web_admin_password_enabled` parameter from the CSRF request causes an else-branch to clear the admin password entirely, leaving the device fully open. No public exploit identified at time of analysis, and the flaw is not listed in CISA KEV.
Stored XSS in SKT Skill Bar WordPress plugin (all versions up to and including 2.6) permits authenticated Contributor-level attackers to persist arbitrary JavaScript into any post or page by exploiting unsanitized handling of the `chart_size` attribute in the `skillwrapper` shortcode. The attribute value is concatenated directly into an inline `<style>` block without sanitization or output escaping, enabling CSS-context breakout and script injection that executes against every subsequent visitor. No public exploit code or CISA KEV listing was identified at time of analysis, though the vulnerable code is publicly browsable in the WordPress plugin repository, lowering the barrier to exploit development.
Stored Cross-Site Scripting in the Simple Yearly Archive WordPress plugin (all versions through 2.2.4) permits authenticated attackers holding Contributor-level access or higher to inject persistent malicious scripts via the `posttype` attribute of the `SimpleYearlyArchive` shortcode. The injected payload is stored in the WordPress database and executes in the browser of any visitor who loads the affected page, enabling session hijacking, credential theft, or administrative account takeover. No public exploit or CISA KEV listing has been identified at time of analysis, placing current exploitation risk in the opportunistic-but-not-mass-exploitation tier.
Denial of service in Cisco IOS XE Software's web-based management interface allows an authenticated remote attacker with low privileges to reload an affected device by presenting a malformed certificate during authentication. The root cause is insufficient error handling (CWE-126, buffer over-read) in the certificate parsing path of the HTTPS management interface, affecting a broad swath of IOS XE releases from 17.3.x through 26.x. No public exploit code exists and the vulnerability is not listed in CISA KEV, but the wide deployment footprint of IOS XE in enterprise and service provider networks makes even a low-probability DoS meaningful at scale.
Path traversal in Amazon's awslabs.aws-transform-mcp-server MCP package (versions 0.1.0-0.1.4) enables a context-dependent actor - which may include a malicious MCP resource, prompt-injected content, or local attacker - to write arbitrary files outside the server's intended working directory by supplying traversal sequences in the savePath parameter of the get_resource tool. The vulnerability carries a CVSS 8.6 (High) score with scope change, meaning exploitation can impact the broader local filesystem beyond the MCP server process itself. No public exploit code or CISA KEV listing has been identified at time of analysis, but a vendor-released patch (version 0.1.5) is available via PyPI and covered under AWS Security Bulletin 2026-075.
Parent process code-sign spoofing in Electron on macOS allows a local low-privileged attacker to bypass fuse-based hardening controls restricting ELECTRON_RUN_AS_NODE and NODE_OPTIONS, injecting code inside the signed Electron application and inheriting its TCC permissions and keychain access. Only macOS deployments of Electron apps that have explicitly enabled same-signed-parent fuse restrictions are exposed; applications without this hardening are unaffected. No public exploit has been identified at time of analysis, and CVSS AC:H reflects the PID-reuse race-condition timing requirement inherent to the attack.
Statamic CMS exposes authenticated users' raw two-factor authentication recovery codes through the Antlers templating engine due to a missing access restriction in the `AugmentedUser::get()` resolver. Unlike `password` and `password_hash` fields, which are explicitly excluded from augmentation, `two_factor_recovery_codes` is returned without restriction and is absent from all Antlers variable guard lists. An administrator or developer who has configured a blueprint field with dynamic Antlers rendering enabled can craft a template (`{{ current_user.two_factor_recovery_codes }}`) that, when rendered by a victim visiting the page, leaks that victim's 2FA recovery codes into the HTML response - enabling 2FA bypass. No public exploit has been identified at time of analysis, and exploitation requires a high-privilege prerequisite (blueprint configuration access).
Authentication bypass in changedetection.io's /settings endpoint silently disables REST API key enforcement when a privileged user or script submits a minimal POST request that omits the api_access_token_enabled checkbox. Because WTForms encodes an unchecked checkbox as False and the settings handler blindly merges all form fields via .update(), the API access token requirement is cleared without any warning, exposing the full watch list, history, and application configuration to unauthenticated REST API callers. No public exploit code or CISA KEV listing has been identified at time of analysis, but the post-exploitation surface - complete unauthenticated API access - is severe.
Reflected Cross-Site Scripting in the Football Pool WordPress plugin (all versions ≤ 2.13.4) allows unauthenticated attackers to inject arbitrary JavaScript into the browsers of authenticated WordPress subscribers via the Shoutbox widget's `shouttext` POST parameter. The flaw is triggered when a shoutbox submission fails validation - nonce mismatch, empty input, or save failure - causing the raw POST value to be echoed unescaped into a `<textarea>` via `printf('%s', ...)`. No public exploit has been identified at time of analysis, and the vulnerability is not listed in CISA KEV, but a remediation commit (changeset 3538628) has been pushed to the plugin trunk.
Reflected XSS in 299Ko CMS's public contact form allows unauthenticated remote attackers to inject and execute arbitrary JavaScript in a victim's browser by submitting unsanitized POST field values that are echoed unescaped into HTML attributes and a textarea. The vulnerability is in the template engine's output function (`_show_var()` in `common/Template.php`), which lacks any `htmlspecialchars()` encoding, and is exploitable against any visitor - including a targeted administrator - enabling session token theft. No CISA KEV listing exists at time of analysis, but the CVE description provides exact code paths and a working payload, making independent exploit development trivial.
Client-side template injection in ember-dynamic-render-template exposes Ember.js applications to cross-site scripting when the render-template component receives attacker-controlled data through its templateString property. The addon's render-template.js passes templateString directly to Ember/Glimmer's compileTemplate() with no sanitization, allowlisting, or validation, causing the runtime to compile and execute arbitrary Handlebars expressions in the victim's browser. All published versions are affected per the CPE wildcard; no CISA KEV confirmation exists and no public exploit code has been identified at time of analysis.
Cross-tenant object exfiltration in OpenStack Swift through 2.38.0 allows authenticated S3 API users to bypass source-object authorization by injecting Swift-native server-side copy headers (X-Copy-From, X-Copy-From-Account) into a signed S3 PUT request. The S3API middleware authorizes the request against the attacker-controlled destination bucket and then forwards the copy headers to Swift's copy engine, which executes the cross-tenant copy without re-evaluating the source object's ACLs or ownership - a classic confused-deputy flaw (CWE-863). Exploitation is constrained to deployments with the non-default s3_acl=true option enabled, and no public exploit is identified at time of analysis.
OpenStack Swift's S3API middleware through version 2.38.0 fails to enforce SigV4 signature coverage over semantic x-amz-* headers on presigned URL requests, enabling unauthorized server-side object copy operations under the signer's authorization context. An attacker holding a valid presigned PUT URL can inject an unsigned X-Amz-Copy-Source header, redirecting Swift's behavior from a client upload into a server-side copy that reads any object accessible to the URL's original signer - effectively allowing privilege escalation within a delegated authorization context. No public exploit or CISA KEV listing was identified at time of analysis, but all deployments running the S3API middleware under the default s3_acl=false configuration are affected.
Path validation bypass in Electron's shell.openPath() allows an attacker-controlled file to be opened in place of one that passed string-based extension validation, due to embedded null bytes not being rejected before OS-level path resolution. Electron-based desktop applications that accept untrusted file paths, validate them using only JavaScript string methods (e.g., endsWith(), regex extension checks), and then pass them to shell.openPath() are affected; apps using Node.js fs APIs (fs.existsSync(), fs.stat()) prior to the call are explicitly not vulnerable. Fixed in versions 39.8.6, 40.9.0, 41.1.1, and 42.0.0-beta.1; no public exploit identified at time of analysis.
Unrestricted HTTP redirect scheme following in Electron's net module (versions prior to 39.8.8, 40.9.0, 41.2.1, and 42.0.0-beta.3) enables server-side request forgery leading to local file disclosure. When net.fetch() or net.request() follows a redirect issued by an attacker-controlled server targeting a local scheme such as file://, the Electron app can be made to read and expose local filesystem contents if it forwards or returns the response body. No public exploit is identified at time of analysis; however, the vulnerability class (SSRF via redirect scheme bypass, CWE-918) is well understood, and the default redirect-following behavior increases the practical surface area across affected apps.
Session isolation bypass in Electron's custom protocol handler allows cached HTTP responses from defaultSession to leak across otherwise isolated session partitions. Electron versions 40.x through pre-release 43.x are affected when apps use ProtocolResponse.url without specifying ProtocolResponse.session, causing upstream requests to be routed through defaultSession regardless of which session registered the protocol handler. An attacker who can trigger a cross-session cache hit may read confidential session-scoped content (C:H) or partially influence cached responses (I:L) intended for a different, isolated session; no public exploit or CISA KEV listing exists at time of analysis.
Electron's permission check handler incorrectly exposes cross-origin iframes to unauthorized camera, microphone, and serial port access by passing the top-level frame's origin as `requestingOrigin` instead of the requesting iframe's own origin. Applications implementing `session.setPermissionCheckHandler` with origin-based grant logic that also embed cross-origin iframes with delegated device permissions are affected - the handler is deceived into approving the iframe's request as if it came from the trusted top-level origin. No public exploit code exists and CISA KEV listing is not confirmed; the CVSS score of 5.9 with AC:H accurately reflects the specific multi-condition deployment pattern required for exploitation.
Code injection in Electron's DevTools API permits arbitrary script execution in the DevTools context via an unsanitized `mode` parameter supplied to `webContents.openDevTools()`. Unsandboxed Electron applications where untrusted input reaches the `mode` argument - or where untrusted content embedded in a `<webview>` element can invoke `openDevTools()` - are exposed to full Node.js-level code execution on the host operating system. No public exploit has been identified at time of analysis, but Electron's own GitHub Security Advisory (GHSA-4f78-qhmw-8j8m) confirms the flaw and vendor-released patches are available across all active release tracks.
Prototype pollution in Eclipse Theia's preference resolution system exposes developers to application-logic manipulation when opening crafted workspaces. The `PreferenceUtils.merge` function in `@theia/core`, invoked for every preference scope resolution, fails to reject reserved JavaScript prototype keys (`__proto__`, `constructor`, `prototype`), allowing a malicious `.theia/settings.json` or `.vscode/settings.json` to corrupt `Object.prototype` across the entire Theia Node.js process. Affected versions span 0.7.0 through 1.73.1 inclusive; no public exploit has been identified at time of analysis, and the CVSS 4.0 score of 5.7 appropriately reflects the social-engineering dependency and required user interaction.
Write operation bypass in the AWS Labs DocumentDB MCP Server before version 1.0.12 allows an authenticated MCP client to execute unauthorized database writes while the server operates in read-only mode. The aggregation pipeline tool failed to block write-capable stages - specifically $out and $merge - enabling low-privilege MCP clients to modify DocumentDB data in direct violation of the configured read-only policy. No public exploit code has been identified and the vulnerability is not listed in CISA KEV; a vendor-confirmed fix is available in release 2026.04.20260408085348.
Bolt protocol handshake decoder in Neo4j Enterprise and Community Editions fails to distinguish overlong capability masks from truncated ones, leaving server-side channels permanently open without producing a finalization message. Any unauthenticated client reaching the Bolt connector (default TCP 7687) can trigger this pre-authentication stall by sending 32 continuation bytes in the capability mask, causing the decoder to loop on the same unread bytes. The CVSS 4.0 vector carries E:P (proof of concept exists) with a low availability impact; no active exploitation has been confirmed via CISA KEV, but the trivial pre-auth trigger and POC availability increase realistic risk to exposed Bolt endpoints.
SQL injection in the imranrisal-dev Student-Management-System login component (loginCheckTest.php) allows unauthenticated remote attackers to manipulate backend database queries via the username and password parameters. A public exploit exists (CVSS 4.0 E:P modifier confirmed), making opportunistic exploitation immediately feasible with no authentication or special preconditions. The vendor was unresponsive to responsible disclosure, and no patch has been released, leaving all deployed instances of this repository permanently exposed.
Keycloak's LDAP storage provider allows delegated administrators to bypass configured search boundaries by supplying a crafted Distinguished Name (DN), exposing account information from unauthorized directory subtrees and triggering unintended user imports into Keycloak local storage. Affected deployments include Red Hat Build of Keycloak, Red Hat Single Sign-On 7, Red Hat Data Grid 8, and the JBoss EAP Expansion Pack. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis; exploitation is constrained to authenticated delegated administrators with access to the LDAP federation interface.
Arbitrary file write via path traversal in IBM Langflow OSS 1.0.0-1.10.3 allows any authenticated user to create directories and write files to arbitrary locations on the server filesystem through the Knowledge Bases API. The flaw stems from unsanitized user-supplied knowledge base names being passed directly into file path construction, making exploitation straightforward once credentials are obtained. No public exploit or CISA KEV listing has been identified at time of analysis; a vendor patch is available.
Credential exposure in HCL Digital Experience and Digital Experience Compose allows sensitive authentication material to be written to web server logs under specific, non-default configurations when the default login portlet is in use. The flaw, classed as CWE-522 (Insufficiently Protected Credentials), means that any party with read access to web server logs - such as operations staff, log aggregation systems, or an attacker who has compromised a log pipeline - may recover cleartext or weakly protected user credentials. No public exploit code has been identified at time of analysis, and active exploitation has not been confirmed by CISA KEV.
Multiple high-severity vulnerabilities in Jenkins core and a range of plugins disclosed in the August 2026 security advisory allow attackers to achieve remote code execution on the Jenkins controller, perform arbitrary file writes, bypass deserialization protections, impersonate users, and enumerate stored credentials. Affected versions include Jenkins 2.575 and LTS 2.568.1 and earlier, with the most critical issues residing in the Remoting deserialization layer (CVE-2026-70426), tar archive handling (CVE-2026-70427), and file parameter path traversal (CVE-2026-70428), all of which ultimately enable code execution on the controller JVM. No public exploit or CISA KEV listing is confirmed at time of analysis, but the attack surface breadth and severity of RCE-capable issues make this advisory a high-priority patching event for any Jenkins deployment.
CVE-2026-70441 is assigned within the Jenkins security advisory published 2026-08-05, which discloses over a dozen vulnerabilities across Jenkins core (2.575 and earlier, LTS 2.568.1 and earlier) and multiple plugins. The provided description is the full oss-security announcement for this advisory batch; the specific vulnerability details mapped to CVE-2026-70441 are not isolated in the available data due to truncation of the source text. The advisory as a whole addresses remote code execution via deserialization filter bypass, arbitrary file write via path traversal and crafted archive extraction, CSRF, permission bypass, and user impersonation flaws. No public exploit, KEV listing, or EPSS score was provided for CVE-2026-70441 individually.
Reflected XSS in OpenBK7231T firmware's OTA update endpoint exposes authenticated admins to JavaScript injection via a crafted link. The `/ota_exec` handler in `src/httpserver/http_fns.c` echoes the `host` query parameter verbatim into an HTML response using `hprintf255()`, without HTML encoding, enabling an attacker to run arbitrary script in the admin's browser session. No public exploit code or CISA KEV listing exists at time of analysis; EPSS data was not provided.
Privilege escalation to SYSTEM in NetKids iMark, a parental control product by Integrated Systems Technologies, Inc. (Japan), allows an authenticated local attacker to execute arbitrary code at the highest privilege level by exploiting an uncontrolled DLL search path. The JPCERT advisory (JVN#28045338) documents two related weaknesses: DLL hijacking via improper search path handling (CWE-427) and a secondary unquoted service path issue, both enabling privilege escalation on affected Windows hosts. No public exploit code or CISA KEV listing has been identified at time of analysis.
Session data tampering in IBM Maximo Application Suite 9.0, 9.1, and 9.2 is possible because the application signs session tokens with a weak HMAC secret, classified under CWE-330 (Use of Insufficiently Random Values). A remote unauthenticated attacker who can derive or predict the HMAC signing key may forge or modify session tokens, undermining session integrity across affected deployments. No public exploit code has been identified, this vulnerability is not listed in the CISA KEV catalog, and a vendor patch is available via IBM's advisory.
Unauthenticated remote information disclosure in IBM Cloud Pak for Business Automation 24.0.0 through 26.0.0 allows network attackers to retrieve sensitive data embedded in externally accessible manifest files. The vulnerability stems from CWE-538, where sensitive configuration or operational data is written into manifest files that are not adequately protected from external access. No public exploit has been identified at time of analysis, and a vendor patch is available via IBM's support portal.
Cluster ID enumeration in SUSE Rancher exposes a reliable oracle via the unauthenticated `/v3/import/{token}_{clusterId}.yaml` endpoint, which performs cluster object retrieval before token validation. Remote unauthenticated attackers can distinguish valid cluster IDs (HTTP 502, triggered by a nil pointer dereference in `pkg/systemtemplate/private_registry.go` when private registry secrets exist) from non-existent ones (HTTP 200), leaking the presence and private-registry configuration status of clusters. This is not listed in CISA KEV and no public exploit code has been identified, but the zero-prerequisite network accessibility makes enumeration trivially scriptable.
Unauthenticated retrieval of the full OpenAPI schema is possible in changedetection.io because the /api/v1/full-spec endpoint in changedetectionio/api/Spec.py lacks the @auth.check_token decorator that protects every other /api/v1/* route. Any network-reachable attacker can issue a plain GET request to this path and receive the complete merged schema - all endpoint paths, accepted parameters, and registered processor plugins - even when API key enforcement is active across all sibling routes. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified, though the attack requires zero prerequisites beyond network access, making opportunistic reconnaissance trivially achievable.
DNS rebinding defeats the SSRF guard in Mealie's AsyncSafeTransport, allowing any authenticated user to read internal HTTP services and cloud metadata endpoints via three recipe API endpoints. The guard resolves a hostname once for validation, passes the check using the public IP returned, but the underlying async transport independently re-resolves the hostname for the actual connection - an attacker controlling DNS can flip the record to a private or metadata IP between these two events. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.
Unauthenticated guild membership enumeration in Spacebar Server (before commit 51da17c) exposes complete member user ID lists for any guild on an instance to any bearer-token holder. The GET /guilds/{guild_id}/roles/{role_id}/member-ids route handler omits the IsInGuildOrFail authorization check present in sibling endpoints, meaning an attacker with any valid account can query membership of guilds they do not belong to. No active exploitation is confirmed (not in CISA KEV) and no public exploit code has been identified; real-world impact is privacy-sensitive membership enumeration enabling targeted social engineering or account correlation.
Remote command injection in livebook-dev Livebook's deployment setup command generator allows an authenticated high-privilege attacker to poison Docker and Fly.io setup commands displayed in the web interface, causing arbitrary shell code to execute on the machine of any user who copies and runs the generated command. Affected versions span 0.13.0 through 0.18.6 and 0.19.0 through 0.19.8. No public exploit has been identified at time of analysis, though the CVSS 4.0 score of 4.9 reflects the high privileges required and the indirect execution path through a secondary user's action.