Processing-instruction target injection in the @xmldom/xmldom JavaScript library allows XML structure breakout through unvalidated characters in Document.createProcessingInstruction() targets. Versions prior to 0.8.15 and 0.9.12 - and all versions of the legacy xmldom package (0.6.0 and earlier, which has no fix) - emit malformed processing instructions when a target contains >, ?, whitespace, or other XML-Name-invalid characters, enabling injection of arbitrary XML structure into the serialized output. No public exploit has been identified at time of analysis, and the CVE is not listed in the CISA KEV catalog.
XML injection in the xmldom serializer allows a crafted DocumentType.name containing '>' or whitespace to prematurely close the <!DOCTYPE ...> declaration and inject arbitrary sibling markup into serialized XML output. The gap exists because XMLSerializer.serializeToString() under requireWellFormed: true validates publicId, systemId, and internalSubset but emits DocumentType.name verbatim, violating the XML Name production consistently enforced for the other fields. Affected packages are @xmldom/xmldom prior to 0.8.15 and 0.9.12, and all versions of the legacy unscoped xmldom (0.6.0 and earlier) for which no vendor-released fix will be issued; no public exploit code or CISA KEV listing has been identified at time of analysis.
XML injection and cross-site scripting in the xmldom JavaScript library allows attacker-controlled tag names to be injected verbatim into serialized XML or HTML output. Applications using @xmldom/xmldom prior to 0.8.14 or 0.9.11, or the legacy xmldom package at any version, are affected when they pass externally-supplied strings to Document.createElement() and then serialize the resulting DOM with XMLSerializer.serializeToString(). The serializer's requireWellFormed: true path failed to validate element qualified names and synthesized xmlns:PREFIX declarations against the XML QName production, meaning malformed names containing characters such as '>' or '<' pass through unchecked and cause XSS when the output is rendered in a browser. No public exploit has been identified at time of analysis, though the GitHub security advisory and PR diffs include explicit test cases demonstrating injection payloads.
XML injection in the xmldom JavaScript library allows crafted attribute names to break out of attribute context during serialization, enabling injection of arbitrary attributes — including event handlers — into browser-consumed XML/HTML output. Applications using @xmldom/xmldom before 0.8.14 or 0.9.11, or any version of the legacy xmldom package (≤0.6.0), are affected when attacker-controlled data reaches Element.setAttribute() and the result is serialized via XMLSerializer.serializeToString(). No public exploit is identified at time of analysis, but the vulnerability class is well-understood and the injection mechanism is straightforward for any attacker who can influence attribute name input.
Quadratic attribute-processing complexity in xmldom's DOMParser enables remote unauthenticated denial of service against any Node.js application that parses externally supplied XML. When a well-formed XML element contains many distinct attributes, DOMHandler.startElement repeatedly calls NamedNodeMap.setNamedItem, which in turn performs a full linear scan of previously inserted attributes on each insertion - producing O(N²) comparisons for N attributes and stalling the Node.js event loop before any application-level validation can execute. @xmldom/xmldom 0.8.15 and 0.9.12 contain the fix; the legacy xmldom package (≤0.6.0) has no patch and will not receive one. No public exploit has been identified at time of analysis, though the attack is trivially constructable from the published advisory alone.
XML injection in @xmldom/xmldom versions 0.9.10 and 0.9.11 bypasses the requireWellFormed serializer's DocumentType validation due to a multiline-flag inheritance bug in the PubidLiteral and SystemLiteral regex matchers: a publicId or systemId whose first line is a valid literal passes the check while ECMAScript line terminators (U+000A, U+000D, U+2028, U+2029) and breakout markup on subsequent lines are emitted verbatim into the <!DOCTYPE ...> declaration. This is a bypass of the mitigation introduced for the earlier DocumentType injection advisory; applications that treat requireWellFormed: true as a serialization-time security boundary against DOCTYPE injection are directly exposed. No public exploit has been identified at time of analysis, and a vendor-released patch is available in version 0.9.12.
XML injection in @xmldom/xmldom 0.9.11 allows attackers who supply crafted element or attribute names containing ECMAScript line terminators (U+000A, U+000D, U+2028, U+2029) to bypass the requireWellFormed: true serialization guard and emit arbitrary markup verbatim into serialized XML output. The bypass exploits the multiline flag inherited by the QName_exact regex in lib/grammar.js, which causes the anchors to match at line boundaries rather than string boundaries - directly circumventing the strict-name validation introduced to close earlier injection advisories. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
Erlang/OTP's inets HTTP server (httpd) fails to enforce an administrator-configured request body-size limit when processing chunked transfer-encoded requests, enabling unauthenticated remote attackers to exhaust server memory and cause denial of service. Affected OTP branches span 17.x through 27.3.4.16, 28.x through 28.5.0.5, and 29.x through 29.0.5, covering inets versions 5.10 through 9.7.1. No public exploit code has been identified and the CVE is not listed in the CISA KEV catalog, but the zero-authentication, low-complexity network attack path makes this an operationally straightforward DoS risk for any deployment exposing inets httpd to untrusted clients.
XML injection in @xmldom/xmldom 0.9.0-0.9.11 allows an attacker to embed malicious markup into serialized XML output by supplying element or attribute names containing ECMAScript line terminators (U+000A, U+000D, U+2028, U+2029). The QName_exact regex in lib/grammar.js is compiled with JavaScript's multiline flag, causing the ^ and $ anchors to match per-line rather than over the full string - a name whose first line is a valid QName passes validation while subsequent lines carry injected markup, bypassing both the default serialization path and requireWellFormed: true. No public exploit has been identified at time of analysis, but the CVSS 4.0 score of 8.7 with no prerequisites reflects the high-integrity impact when an application passes attacker-controlled input to createElementNS, createAttributeNS, createDocumentType, or createAttribute.
Unauthenticated atom table exhaustion in ash_typescript 0.1.0-0.17.x allows any network attacker to crash the entire Erlang/BEAM node by submitting RPC requests with attacker-controlled field names. The library's `convert_to_field_atom/2` function calls `String.to_atom/1` on client-supplied strings without validation, minting permanent, non-garbage-collected atoms until the VM hits its table limit and aborts. Additionally, field names exceeding 255 characters trigger an uncaught `SystemLimitError`. No public exploit is identified at time of analysis, but exploitation is trivial given no authentication or special configuration is required.
ReDoS in @xmldom/xmldom versions 0.7.0 through 0.8.14 allows remote unauthenticated attackers to stall the Node.js event loop by submitting a small crafted XML document containing a malformed end tag. The SAX parser in lib/sax.js uses an unanchored global regex /[ \t\n\r]+$/g to trim end-tag names; a tag with N whitespace characters followed by one non-whitespace character causes the engine to retry the match from every character position with O(N) backtracking per position, yielding O(N²) total work that blocks the single-threaded event loop. No public exploit code or CISA KEV listing is identified at time of analysis, but the CVSS 4.0 score of 8.7 with VA:H and PR:N reflects the severity of unauthenticated, network-reachable availability impact.
Quadratic CPU and memory exhaustion in @xmldom/xmldom 0.9.0-beta.1 through 0.9.11 allows denial-of-service via small crafted HTML documents passed to DOMParser.parseFromString(). The parseHtmlSpecialContent function uses a case-sensitive indexOf() to locate closing tags for raw-text elements; when a mixed-case tag like </ScRiPt> is not found, indexOf() returns -1, and the subsequent substring(-1) call destabilizes parser progression and triggers O(N²) output amplification. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified, but the attack is unauthenticated and requires no access complexity beyond supplying crafted HTML to the parser.
Quadratic regex backtracking in @xmldom/xmldom versions 0.9.0-beta.9 through 0.9.10 allows unauthenticated remote attackers to stall the Node.js event loop by supplying a small malformed XML document containing an unterminated processing instruction with a long whitespace tail. The flaw resides in the processing-instruction production regex in lib/grammar.js, where the greedy S+ separator and lazy Char*? data group endlessly repartition whitespace when the required closing ?> is absent, causing O(n²) backtracking in both parsePI and parseProcessingInstruction. No public exploit has been identified at time of analysis, but the fix commit and GitHub Security Advisory GHSA-g53g-w8rj-fmg7 fully document the vulnerable code path, making independent reproduction straightforward. Vendor-released patch: 0.9.11.
UNION-based SQL injection in AVideo through version 29.0 allows unauthenticated remote attackers to read arbitrary database contents via the User_Location plugin's regions.json.php and cities.json.php endpoints. The country and region GET parameters are passed unsanitized into SQL queries without prepared statement binding, enabling direct extraction of password hashes and sensitive configuration data from the underlying database. No public exploit has been identified at time of analysis, but the UNION-based technique is elementary and well within reach of automated scanning tooling.
Rate-limit bypass in WWBN AVideo (all versions) allows unauthenticated remote attackers to perform unlimited credential-guessing against login endpoints by rotating arbitrary X-Real-IP or X-Forwarded-For header values per request. The enforceRateLimit() function uses the attacker-supplied header as the client identifier without verifying the request originates from a trusted proxy, nullifying IP-based throttling entirely. No public exploit code has been identified at time of analysis, but the technique requires no specialised tooling beyond basic HTTP scripting.
Cross-site request forgery in WWBN AVideo's referer-validation logic allows unauthenticated remote attackers to trick administrative users into issuing forged requests that modify live server configuration. The flaw resides in the get_domain() and isSameDomain() functions, which fail to reject origins from sibling subdomains or malformed long-gTLD URLs, enabling forged admin-level ObjectYPT writes. No public exploit code or active exploitation has been identified at time of analysis, but the bypass is straightforward to weaponize against any deployment where an attacker can influence an admin to visit a malicious page.
Unauthenticated denial-of-service in Rockwell Automation RSLinx Classic allows a remote attacker to crash the communications service by sending a crafted CIP packet containing an oversized embedded message request. The buffer overflow (CWE-120) causes the RSLinx Classic service to terminate, requiring manual restart to restore industrial device connectivity. In OT/ICS environments where RSLinx Classic bridges engineering workstations to Allen-Bradley PLCs and HMIs, service loss can halt production operations or degrade visibility into live industrial processes. No public exploit or CISA KEV listing confirmed at time of analysis.
Denial-of-service in Rockwell Automation RSLinx Classic allows unauthenticated remote attackers to crash the communication service by sending a specially crafted CIP packet with a manipulated data length field. The root cause is an integer underflow (CWE-191) in the packet length validation routine, causing the service to terminate and requiring a manual restart to recover. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the zero-barrier network attack vector against a critical ICS communication layer makes this a high-priority remediation target.
Denial-of-service in Rockwell Automation RSLinx Classic allows unauthenticated remote attackers to crash the RSLinx Classic communication service by sending a single crafted CIP packet targeting the Forward Close service. Because RSLinx Classic acts as the primary communication bridge between engineering workstations and Allen-Bradley PLCs, a crash forces a manual service restart and can halt production operations in industrial environments. No public exploit code has been identified at time of analysis, and this CVE is not listed in the CISA Known Exploited Vulnerabilities catalog.
Unauthenticated remote denial-of-service in Rockwell Automation CompactLogix 5380 and ControlLogix 5580 industrial controllers allows a network-adjacent attacker to trigger a Major Nonrecoverable Fault (MNRF) by sending a malformed CIP message with an invalid input length, requiring a physical power cycle to restore controller operation. The vulnerability is rooted in CWE-119 (improper buffer bounds restriction) during CIP message processing on EtherNet/IP-accessible PLCs. No public exploit code or active exploitation has been identified at the time of this analysis, but the zero-prerequisite network attack surface on safety-critical industrial hardware makes this a prioritized remediation target for OT security teams.
Denial-of-service in a Rockwell Automation industrial module allows unauthenticated remote attackers to crash the device by sending a single crafted CIP (Common Industrial Protocol) packet, requiring a manual restart to restore availability. The vulnerability affects operational technology (OT) environments where CIP is network-accessible, making it particularly dangerous in industrial control system (ICS) contexts where device downtime can disrupt physical processes. No public exploit code has been identified at time of analysis, and Rockwell Automation has published advisory SD1798 addressing the issue.
Rockwell Automation's ArmorStart LT industrial motor control device contains a denial-of-service flaw in its embedded web server, exploitable by sending a crafted HTTP PUT request with no authentication or special preconditions. The root cause (CWE-770) is improper resource throttling during HTTP PUT processing, which causes the web server to become unavailable. No public exploit code has been identified and the vulnerability is not listed in CISA KEV, but the unauthenticated network attack surface in an OT/ICS context makes this a material operational risk wherever the device's web interface is reachable.
Broken authorization in OpenNebula's `one.vm.exec` API function allows any authenticated low-privilege user to execute arbitrary commands inside virtual machines owned by other users, across all versions prior to 7.4. The flaw stems from the platform's failure to verify whether the requesting user holds access rights to the target VM - only the VM's numeric identifier and an active qemu-agent are required. Full confidentiality, integrity, and availability compromise of victim VMs is achievable by any platform tenant; no public exploit has been identified at time of analysis, but the low complexity prerequisites make this a genuine priority for multi-tenant deployments.
Unauthenticated remote access to the HPE Networking Fabric Composer API allows attackers to read limited internal system information and make unauthorized changes to certain configuration settings, potentially disrupting fabric management operations. The CVSS 8.6 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:L) and the 'Authentication Bypass' tag confirm that no credentials are required for network-based exploitation. No public exploit code and no CISA KEV listing have been identified at time of analysis.
Persistent account takeover in Memos 0.26.0-0.30.0 is enabled by a failure to invalidate refresh tokens upon password change. An attacker who possesses a stolen refresh token can indefinitely call the RefreshToken RPC to rotate both the refresh token and obtain fresh access tokens, making the victim's password-change security response completely ineffective. No public exploit has been identified at time of analysis, but the vulnerability is straightforward to exploit once a token is obtained, and CVSS 4.0 rates the impact as High on both confidentiality and integrity.
Remote code execution in Rockwell Automation FactoryTalk® Historian Machine Edition allows an adjacent-network attacker holding low-privilege credentials to fully compromise the historian host via a memory corruption flaw. The root cause is CWE-787 (Out-of-bounds Write), consistent with a buffer overflow in the historian's network-facing service, yielding full confidentiality, integrity, and availability impact on the affected device. No active exploitation has been confirmed in CISA KEV and no public proof-of-concept has been identified at the time of analysis.
Cleartext HMAC key exposure in Amazon SageMaker Python SDK's @step and @remote decorator components (versions before v2.256.0 and v3.11.0) lets any authenticated IAM principal within the same AWS account read the signing key from DescribePipeline API responses, then forge valid integrity signatures to inject attacker-controlled code into a victim user's pipeline execution context. No public exploit has been identified and the vulnerability is absent from the CISA KEV catalog, but the attack chain is mechanically straightforward for any account member holding the sagemaker:DescribePipeline permission. Vendor-released patches for both SDK branches are confirmed via GitHub release tags v2.256.0 and v3.11.0 and AWS Security Bulletin 2026-093-aws.
Privilege escalation in the HPE Networking Fabric Composer API allows authenticated low-privilege operator users to invoke state-changing API operations beyond their authorized scope, including modifications to configurations of network systems managed by the platform. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:C/I:H) confirms the flaw is remotely exploitable with no complexity or interaction requirements, and that the integrity impact extends beyond Fabric Composer itself to the downstream network infrastructure it manages. No public exploit code or CISA KEV listing is present at time of analysis, but the low exploitation barrier - a valid low-privilege credential - makes this a meaningful insider and credential-theft escalation risk.
Privilege escalation in Easybyte Software's Konga before 2.1.0 allows any authenticated local Windows user to execute arbitrary code at the privilege level of the account running Konga by planting attacker-controlled OpenSSL configuration or library files in a hardcoded filesystem path that is absent from default installations and resides in a location writable by all authenticated users. The root cause is CWE-427 (Uncontrolled Search Path Element): Konga loads OpenSSL from a fixed, predictable path without verifying the integrity or provenance of files found there, enabling a classic library-planting attack. No public exploit code or CISA KEV listing has been identified at time of analysis; a vendor patch is available in version 2.1.0.
Privilege escalation in Rockwell Automation FactoryTalk® Activation Manager exposes authenticated local Windows users to full SYSTEM-level access by exploiting visible console windows spawned by the installer's custom actions during installation or repair operations. Any low-privileged user present on the machine during an install or repair sequence can interact with these unprotected, SYSTEM-privileged console windows to launch an unrestricted command shell. No public exploit has been identified at time of analysis, but the attack technique - console window hijacking during elevated installer operations - is a well-documented Windows privilege escalation class requiring minimal skill once the precondition is met.
Stored cross-site scripting in the HPE AOS-CX web-based management interface allows an authenticated attacker with high privileges to inject persistent malicious script that executes in the browser of any administrator who subsequently views the affected page. Because the scope changes to the victim's browser context, a successful exploit enables session hijacking, credential theft, or execution of privileged management actions against AOS-CX network infrastructure. No public exploit code has been identified at time of analysis, and this CVE is one of several addressed in HPE security bulletin hpesbnw05134en_us alongside CVE-2026-73749, CVE-2026-73766, and CVE-2026-73778.
Remote unauthenticated attackers can exploit Erlang/OTP's built-in inets HTTP server across OTP versions 22.2 through 29.0 to conduct HTTP Request Smuggling by sending headers with whitespace before the colon - a malformed construct the server silently discarded rather than rejecting as mandated by RFC 7230 Section 3.2.4. When inets is deployed behind a front-end proxy or load balancer that interprets such headers differently, the resulting parsing discordance creates a desynchronized request boundary exploitable for session hijacking, authentication bypass, or cache poisoning. No public exploit has been identified at time of analysis; vendor-released patches are available across all three affected OTP release branches.
HTTP request smuggling in Erlang/OTP's built-in inets httpd server allows unauthenticated remote attackers to inject arbitrary HTTP headers and poison request pipelines in deployments fronted by a reverse proxy. The root cause is a longstanding absence of obs-fold support: any CRLF followed by a whitespace octet (SP or TAB) is silently parsed as a new header rather than a header continuation, causing proxy-backend disagreement on request boundaries. Affected versions span OTP 17.0 through the patched releases (27.3.4.17, 28.5.0.6, 29.0.6), with vendor patches now available via the Erlang GitHub security advisory. No public exploit code or CISA KEV listing exists at time of analysis.
Request smuggling in Erlang OTP inets (versions 17.0 through 29.x) arises when the httpd server sits behind a Content-Length-preferring reverse proxy: inets frames the request body by chunked Transfer-Encoding and silently discards a co-present Content-Length header, while the front-end proxies request boundaries by Content-Length, producing a classic CL.TE desync. An unauthenticated network attacker in this topology can inject a crafted prefix into a subsequent victim's HTTP request, potentially enabling session hijacking, credential theft, or cache poisoning against other users of the same back-end. No public exploit has been identified at time of analysis, the vulnerability is not listed in CISA KEV, and vendor patches are available for the OTP 27.x, 28.x, and 29.x release branches.
Privilege escalation in HPE Networking Fabric Composer allows an authenticated low-privilege operator to exploit business logic flaws in the product API, obtaining elevated privileges and modifying system settings beyond their authorized scope. The CVSS 3.1 score of 8.3 (AV:N/AC:L/PR:L/UI:N) reflects that exploitation is network-accessible, low-complexity, and requires only a valid operator credential. No public exploit code or CISA KEV listing has been identified at time of analysis.
Credential leakage in Kyverno's apiCall service mode automatically forwards the Kubernetes admission controller's ServiceAccount bearer token to any external HTTP endpoint referenced in a policy, including attacker-controlled servers. Affecting Kyverno before 1.16.4 (fix version disputed - see confidence notes), this insecure-by-default behavior requires only policy-creation privileges to exploit: a low-privileged user crafts a ClusterPolicy pointing apiCall.service.url at an attacker-controlled host, then triggers a matching admission event, causing Kyverno to self-exfiltrate its SA token. No public exploit is confirmed in CISA KEV, but a working proof-of-concept with full reproduction steps is embedded in the GitHub security advisory GHSA-8wfp-579w-6r25.
Server-side request forgery in Kyverno's Kubernetes admission controller (all versions before 1.18.0) enables any authenticated cluster user to redirect the admission controller's privileged HTTP client to cloud metadata endpoints (e.g., AWS IMDS at 169.254.169.254), internal ClusterIP services, and loopback addresses by injecting malicious URLs through JMESPath variable substitution in ClusterPolicy `apiCall.service.url` definitions. Critically, this is non-blind SSRF: response bodies are reflected back to the attacker through admission error messages visible in kubectl output, enabling direct credential and data exfiltration in a single API call. A fully functional proof-of-concept is published in GHSA-qr4g-8hrp-c4rw; no confirmed active exploitation (CISA KEV) has been identified at time of analysis.
Cross-site request forgery exposure in HPE AOS-CX switch web management interface enables remote unauthenticated attackers to force arbitrary administrative actions against the switch by tricking an authenticated administrator into visiting a specially crafted URL. The vulnerability is partial - only "some sessions" within the management interface lack CSRF token enforcement, suggesting inconsistent protection coverage rather than a complete absence. No public exploit code or active exploitation has been identified at time of analysis.
Arbitrary OS command execution in HPE Networking Fabric Composer allows an unauthenticated attacker on an adjacent network segment to run arbitrary commands on the underlying host, achieving full system compromise. Exploitation depends on preconditions outside the attacker's direct control, which constrains practical risk and drives the AC:H rating despite the severity of the impact. No public exploit or active exploitation has been identified at time of analysis; HPE has published a security bulletin (hpesbnw05133en_us) addressing this issue.
Unauthenticated file disclosure in Erlang/OTP's inets httpd allows remote attackers on case-insensitive filesystem deployments to read files inside mod_auth-protected directories by requesting them with differently-cased path segments. The flaw spans OTP 17.0 through 29.x (inets 5.10 through 9.7.x) and stems from mod_auth's path-matching regex omitting the caseless flag, causing authentication checks to be silently bypassed when request path casing differs from the configured directory name while the filesystem resolves both to the same file. No public exploit code or active exploitation has been identified at time of analysis, and deployments on case-sensitive filesystems - the default on Linux - are fully unaffected by this vulnerability.
Authentication bypass in Erlang/OTP inets httpd allows remote unauthenticated attackers to read files inside mod_auth-protected directories across OTP 17.0 through 29.0 by prefixing the request URI with an extra slash. The inets URI normalizer preserves doubled slashes that RFC 3986 dot-segment removal does not collapse, causing mod_auth's directory-protection regex to silently fail to match while the OS transparently serves the protected file. No CISA KEV listing or public exploit code has been identified at time of analysis; CVSS 4.0 scores this 8.2 with high confidentiality impact contingent on mod_auth being explicitly configured.
Privilege escalation in Kibana allows an authenticated user holding workflow edit permissions to cause scheduled workflow executions to run under the privileges of a higher-privileged user, granting unauthorized read and write access to data outside their authorization scope. The flaw (CWE-863, Incorrect Authorization) stems from Kibana's workflow scheduling subsystem failing to enforce authorization boundaries when executing scheduled jobs - a pattern classified under CAPEC-180. No public exploit exists at time of analysis, but the CVSS 8.3 (High) score with a network-accessible, low-privilege attack vector reflects genuine impact for any multi-user Kibana deployment. Elastic's advisory ESA-2026-61 references Kibana 9.4.3 as the fix release.
The BEAM runtime in Erlang/OTP crashes when a remote attacker sends a crafted packet to any exposed TCP port using the inet driver with {packet,4} framing, exploiting a signed integer overflow in packet length calculation inside packet_parser.c and inet_drv.c. Affected deployments span OTP release lines 17 through 29, with vendor-released patches available (27.3.4.17, 28.5.0.6, and 29.0.6); no active exploitation is confirmed in CISA KEV and no public exploit code has been identified at time of analysis. The vendor explicitly characterizes remote code execution as 'extremely unfeasible,' making denial-of-service via VM crash the realistic worst-case impact.
Unbounded memory exhaustion in the Erlang/OTP inets httpc HTTP client allows any server the client connects to - including via redirect or man-in-the-middle - to crash the BEAM VM by returning an arbitrarily large volume of response headers. The root cause is that max_header_size defaults to the atom nolimit and the header accumulation loop in httpc_response:parse_headers/6 collects all header data into an in-process list before any size check fires. A proof-of-concept server delivering 100,000 headers of ~4,000 bytes each consumed over 13 GB of RAM in under 30 seconds; no public exploit code has been separately released but the PoC is embedded in the official advisory, and vendor patches are available for OTP 27, 28, and 29 branches.
Incomplete script filtering in SVGO's opt-in removeScripts plugin allows stored XSS to survive the sanitization pass across versions 1.0.0 through 2.8.3, 3.3.4, and 4.0.x in applications that process attacker-controlled SVG and serve the result in a browser context. The plugin fails to recognize namespace-prefixed SVG anchor elements such as svg:a and does not strip ASCII tab, line-feed, or carriage-return characters from URL values before scheme validation - characters browsers silently discard before parsing, allowing javascript: URIs to bypass detection intact. Vendor-released patches exist at v2.8.4, v3.3.5, and v4.1.0; no public exploit or CISA KEV listing was identified at time of analysis.
Unauthenticated BEAM atom table exhaustion in ash_typescript 0.11.0-0.17.x allows a remote attacker to abort the Erlang VM and take down the entire application node by sending RPC requests carrying many distinct, unrecognized field names targeting a typed struct field selector. The root cause is `resolve_typed_struct_field/2` calling `String.to_atom/1` on unresolvable client input before any field-existence validation, permanently minting atoms that the BEAM runtime never reclaims. A vendor-released patch is available in 0.18.0; no public exploit code or CISA KEV listing exists at time of analysis.
SSRF in GitHub Enterprise Server (all versions prior to 3.22) allows unauthenticated network attackers to force the Manage API to issue gateway-to-agent requests toward an attacker-controlled host, and - by intercepting those outbound requests - capture a weakly-scoped HMAC token replayable against privileged management agent endpoints. The flaw arises from an unauthenticated cluster-configuration parsing endpoint combined with an HMAC scheme that signs only a timestamp, leaving request paths and bodies unsigned and the captured token replayable with arbitrary content. Vendor-released patches are available across five supported branches (3.17.19, 3.18.13, 3.19.10, 3.20.6, 3.21.4); no public exploit code and no CISA KEV listing have been identified at time of analysis.
Unauthenticated remote exploitation of an API endpoint in HPE Networking Fabric Composer can cause high-impact denial of service requiring manual administrator intervention, along with limited unauthorized modifications to the underlying operating system. The CVSS 8.2 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:H) confirms no authentication, no special conditions, and network-level accessibility with no user interaction required. No public exploit code or active exploitation is confirmed at time of analysis, but the management-plane targeting makes this a remediation priority for organizations running HPE fabric orchestration infrastructure.
Field policy enforcement in ash_typescript RPC serialization is bypassed by a missing pattern-match clause, allowing unauthenticated remote callers to receive the real values of attributes that Ash field policies explicitly denied. Any action returning an embedded resource through the RPC layer exposes policy-protected fields - including sensitive PII such as SSNs, as demonstrated in the patch test suite - inside the serialized JSON response. Affects ash_typescript 0.11.0 through 0.17.x; no public exploit code exists at time of analysis, but the attack path is fully described in the vendor advisory and the two-line fix diff.
Authentication bypass in HPE AOS-CX switch operating system allows an adjacent unauthenticated attacker, under high-complexity conditions, to circumvent authentication controls and achieve both integrity compromise and sensitive information exposure. The scope change in the CVSS vector (S:C) indicates successful exploitation can extend impact beyond the directly targeted switch - relevant in networked environments where a compromised switch becomes a pivot point. No public exploit code or CISA KEV listing is present at time of analysis.