Stored cross-site scripting in the Crocoblock JetElements For Elementor WordPress plugin (versions from n/a through 2.9.2.5) lets a low-privileged account - contributor or author level - persist a script payload that then executes in another user's browser, typically an administrator's, when the affected page is loaded. The plugin does not neutralize input before it is rendered into a web page (CWE-79), and because the CVSS vector carries a scope change (S:C), the injected script runs with the victim's privileges against the surrounding site rather than staying confined to the vulnerable component. Impact is bounded to confidentiality, integrity and availability at low severity, and no public exploit has been identified at time of analysis, with no CISA KEV entry; the current priority is manage-this-month rather than an emergency response.
Sensitive information disclosure in the WordPress plugin Media Library Assistant through version 3.42 allows authenticated users with low privileges to retrieve embedded confidential data from responses sent by the plugin. The flaw is rated CVSS 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), requires a network-reachable request with no user interaction, and no public exploit was identified at time of analysis.
Stored cross-site scripting in the Geo Mashup WordPress plugin through 1.13.22 allows an authenticated low-privilege user to place script in plugin-stored content that executes when another user views the affected page. The flaw is rated 6.5 (medium) with CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:L, and affected sites are those running the plugin on WordPress. No public exploit was identified at time of analysis, and the specific vulnerable field or parameter is not identified in the available sources.
Stored cross-site scripting in the Better Post & Filter Widgets for Elementor WordPress plugin, affecting versions through 1.9.1, allows an authenticated low-privilege user to save input that executes in a victim's browser when the affected page is viewed (CVSS 6.5, CWE-79). Exploitation requires a low-privileged account and victim interaction; no public exploit identified at time of analysis.
Stored cross-site scripting in the WordPress plugin Lazy Load for Videos through version 2.18.11 allows an authenticated low-privileged user to persist script content that executes in another user's browser when the affected page is viewed. The CVSS 6.5 rating reflects network reachability, required victim interaction, and scope change with limited confidentiality, integrity, and availability impact. No public exploit identified at time of analysis, and no CISA KEV entry is present in the provided data.
Reflected cross-site scripting in the WordPress plugin Ad Inserter (versions through 2.8.18) allows an attacker to have a crafted request reflected into a page the plugin generates, executing script in the context of a targeted logged-in victim's browser; the flaw is rated CVSS 6.5 (medium, CWE-79) and was reported by Patchstack. Exploitation is constrained by a mandatory user-interaction step (UI:R) and by the fact that each victim must be individually lured, and only sites running the affected plugin versions are exposed. There is no KEV listing and no public exploit identified at time of analysis; the supplied CVSS vector scores PR:L while the independent assessment re-scores the vector as PR:N, so the exact authentication prerequisite is not confirmed from available data.
Missing authorization in the Better Post & Filter Widgets for Elementor plugin through version 1.9.1 allows a low-privilege authenticated user, such as a registered subscriber, to read sensitive data that the plugin should restrict. The assessed CVSS 3.1 score is 6.5 with a vector of AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, so the impact is confidentiality-only and requires a valid account on the WordPress site; the plugin must also be installed and active with Elementor. No public exploit was identified at time of analysis and CISA KEV does not list this CVE; the issue is considered moderate priority rather than an emergency.
Stored cross-site scripting in the Royal Elementor Addons WordPress plugin (WProyal) through version 1.7.1069 lets a low-privileged authenticated user persist malicious markup that executes in another user's browser when the affected page is viewed. The assessed vector (CVSS 6.5, AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:L) requires a contributor/author-tier account to plant the payload and a separate victim to render it, so impact is bounded to the victim's browser session rather than server compromise. No public exploit code or confirmed active exploitation was reported in the available sources, and the vuln.today priority is 'this_month', indicating scheduled rather than emergency remediation.
DOM-based cross-site scripting in the WProyal Royal Elementor Addons WordPress plugin (all versions through 1.7.1069) allows a low-privileged authenticated user to execute script in another user's browser session when that victim views crafted content. The CVSS 3.1 vector scores it 6.5 (AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:L): the attacker needs an account on the target WordPress site, a separate victim must interact with the injected page, and impact is limited to client-side script execution in the victim's browser rather than server compromise. No public exploit code or active exploitation has been identified at time of analysis, and the available priority signal places this in the current-month remediation window rather than an emergency response.
Stored cross-site scripting in the WordPress plugin Gutenberg Blocks by Kadence Blocks (versions through 3.8.0.1) lets a low-privileged authenticated user persist script-bearing content that executes in another user's browser when that content is rendered. Per the assessed vector (CVSS 6.5, AV:L/AC:L/PR:L/UI:R/S:C), an attacker must already hold a content-contributing account such as contributor or author, and impact only materializes when a separate victim - typically a higher-privileged user viewing the affected page - loads the injected content. The issue was reported by Patchstack and is scheduled for this-month remediation priority; no public exploit code or active exploitation (CISA KEV) is associated with it at time of analysis, though successful exploitation crosses a privilege boundary (scope change) and can yield limited confidentiality, integrity and availability effects.
Stored cross-site scripting (CWE-79) in the bPlugins Image Gallery Block WordPress plugin (slug 3d-image-gallery) lets a low-privileged authenticated user - contributor/author level with content-creation rights - persist script payload through the plugin's block input, which executes in the browser of another user who later views the affected page. Rated CVSS 3.1 6.5 (AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:L), exposure is bounded by two prerequisites: the attacker must hold an account able to add or edit the gallery block, and a victim must interact with the crafted page, so exploitation is not self-propagating. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor advisory linked from the CVE record is the primary reference; the issue is triaged for remediation within the current monthly cycle rather than emergency action.
An out-of-bounds read in the Q.931 information-element parser of the chan_ooh323 H.323 addon channel driver lets unauthenticated remote attackers crash Asterisk 20.x, 21.x, 22.x and 23.x releases (fixed in 20.20.1, 21.12.3, 22.10.1 and 23.4.1) plus Certified Asterisk 20.7-cert and 22.8-cert branches (fixed in 20.7-cert11 and 22.8-cert3) by sending a crafted Q.931 setup packet. Exposure is strongly conditional: chan_ooh323 is not part of a default build and must be explicitly compiled and installed, and its listening port must be reachable from the attacker's network. Impact is limited to denial of service (availability only, no confidentiality or integrity effect); EPSS is 0.56% (46th percentile) and no public exploit code and no CISA KEV entry were identified at time of analysis, so this is a timely-patching item rather than an emergency.
NocoDB through 2026.07.0 lacks effective restriction on excessive authentication attempts in the validatePassword function reached through /auth/user/signup, allowing remote unauthenticated attackers to perform high-complexity signup-related authentication probing with low confidentiality impact and no integrity or availability effect. The vendor treats the behavior as intentional, deleted the related GitHub issue, and did not respond to disclosure contact, so no vendor-released fix is identified. No public exploit was identified at time of analysis, and the low-to-moderate priority ('this_month') reflects the high attack complexity and limited impact despite the medium CVSS 4.0 base score.
HashiCorp Consul and Consul Enterprise contain an authorization bypass (CWE-639) in health check registration that lets an authenticated user with a valid ACL token modify health checks belonging to a different service on the same node, affecting only integrity and availability at a low level (CVSS 6.4, PR:L). Both Community Edition and Enterprise are impacted, with fixes released in Consul Community Edition 2.1.0 and Consul Enterprise 2.1.0 plus the 1.21.19 maintenance branch. There is no indication of active exploitation (not in CISA KEV) and no public exploit code is identified in the available data, so this is a moderate, non-emergency patching priority.
An out-of-bounds read in the flatcc FlatBuffers verifier (check_header, through version 0.6.4) lets a crafted buffer crash 32-bit applications that verify untrusted input. The root cause is an integer overflow in offset arithmetic whose guard is dead code - the condition `uoffset_size <= voffset_size` is always false because uoffset_t is 4 bytes and voffset_t is 2 bytes - so on 32-bit builds the wrap bypasses the bounds check and reads memory before the buffer. Impact is availability only (process crash; no code execution or data disclosure per available evidence), exploitation requires both a 32-bit build and a verifier pass over attacker-supplied data, no public exploit code has been identified at time of analysis (SSVC exploitation: none, EPSS 0.38%, 32nd percentile), and an upstream fix commit is available.
An out-of-bounds read in flatcc's JSON parser runtime (__flatcc_json_parser_number, src/runtime/json_parser.c) affects versions 0 through 0.6.4 and lets an attacker who supplies untrusted JSON that terminates immediately after a decimal point force a one-byte read past the end of the input buffer. The realistic outcome is a process crash, and only when the buffer ends exactly at an unmapped page; otherwise the over-read is benign, which is why the assessed severity is denial-of-service with a high attack-complexity precondition rather than a high-severity emergency. No authentication or user interaction is required, but there is no confidentiality or integrity impact. This is not in CISA KEV and EPSS is low at 0.38% (32nd percentile); a public technical write-up of the flaw has been published, but no working exploit code is confirmed, and the vendor fix is an upstream commit rather than a confirmed tagged release.
Unauthenticated resource exhaustion in NocoDB up to 2026.07.0 lets remote attackers drive repeated refresh/OAuth token invalidation through the public signup endpoint, depleting server capacity. The weakness is the absence of in-app rate limiting on /auth/user/signup and the password-forgot flow: the PublicApiLimiterGuard is a pass-through and each request reaches UserRefreshToken.deleteAllUserToken, so sustained high-volume request flooding amplifies per-request work and resource allocation (CWE-770). No authentication or user interaction is required, but exploitation is high complexity and described as difficult, with impact limited to availability; there is no confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis, and the vendor treats the limiter design as intentional, expecting rate limiting to be enforced externally.
Cleartext transmission of sensitive information in HeyCyan App 1.0.103 on Android arises from the app's Network Security Configuration in AndroidManifest.xml, which permits non-TLS traffic that can be passively observed by anyone able to inspect the app's network path. Realistic exploitation requires the attacker to already hold a man-in-the-middle position - a hostile hotspot, ARP/DNS spoofing, or a compromised network hop - which is why the issue is rated high complexity despite needing no authentication or user interaction. Impact is confidentiality-only, the specific data exposed is not described in the available sources, and no public exploit code is confirmed; the vendor was contacted about the disclosure but did not respond, and the available signals place this below urgent priority.
A delimiter-injection flaw in Mem0's session-scope key construction lets a legitimate caller of the Python or TypeScript SDK (or the REST POST /memories endpoint) collapse two different tenant identifiers onto the same recent-conversation buffer key, disclosing another tenant's last-N raw messages and allowing that history to be evicted or interleaved. Affected are Python SDK releases before 2.0.18 and TypeScript SDK releases before 3.1.6 when _build_session_scope()/buildSessionScope() joins caller-controlled user_id, agent_id, and run_id with unescaped & and = characters. Exploitation requires a multi-tenant deployment that passes a client-supplied identifier straight through as run_id or agent_id and prior knowledge of the victim's exact identifiers, so risk is conditional rather than immediate; EPSS is 0.11% (1st percentile), there is no CISA KEV entry, and no public exploit code is confirmed - the advisory's reproduction script and a public PoC reference exist, but they are not verified as working exploit code. Vendor-released patches are available in Python SDK 2.0.18 and TypeScript SDK 3.1.6.
An out-of-bounds heap read in Open5GS 2.6.1 through 2.8.0 sits in the SBI SUCI de-concealment helper parse_scheme_output() (lib/sbi/conv.c), where the length guard omits the 5-byte MSIN component and lets a 42-byte scheme output be processed with only a 41-byte bound. A remote unauthenticated UE or SBI peer can deliver a crafted SUCI to a UDM that has home-network de-conceal private keys configured, causing a 3-4 byte over-read at the cipher-text and MAC-tag copy; the read data is never placed on the wire and the operation is silent under talloc, so there is no attacker-observable disclosure and no practical crash. Exploitation is config-gated and requires high crafting precision (AC:H/AT:P), no public exploit code was identified at time of analysis, and the reporter holds a PoC privately on request; the assessed CVSS 3.1 vector is AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N, consistent with the medium 6.3 CVSS 4.0 base score but a low practical priority.
Bandit, the pure-Elixir HTTP/WebSocket server, keeps running a WebSock application's handler code after the server has initiated a close, so a remote client that ignores the Close frame can still reach handle_in/2 and handle_info/2 with the state from the {:stop, ...} tuple. Versions 0.5.1 through 1.14.0 are affected (fixed in 1.14.0), and the practical impact lands on WebSock applications that use {:stop, ...} to enforce authorization - a client refused in init/1 after a failed token check, or a kicked/banned user (including Phoenix's :socket_drain path), can keep invoking sensitive actions until it sends Close, TCP drops, or the idle timeout fires, and each client frame resets that timeout. The vendor advisory includes a step-by-step proof-of-concept walkthrough; a public PoC reference exists, but it is not verified as working exploit code, and there is no confirmed active exploitation (CISA KEV).
HTTP request smuggling in the Elixir Bandit web server (1.12.4 up to but not including 1.14.0) lets an unauthenticated remote attacker slip a second request past a front-end proxy by embedding a bare LF in a chunk extension. Because Bandit's HTTP/1.1 chunked reader treats the chunk-size line as everything up to the first CRLF and discards anything after ';' without validating it against the RFC 9112 chunk-ext grammar, Bandit can end a body early and dispatch a trailing 'GET /admin' as its own pipelined request, while a proxy that terminates the size line at the bare LF forwards the same bytes as a single POST. Impact is bounded by a hard precondition: there must be a front-end proxy that treats a bare LF as a line ending and forwards chunked bodies unchanged (the AT:P requirement, outside attacker control) - deployments without such a proxy are not affected. Severity is medium (CVSS 4.0 base 6.3; independently assessed as CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:L/A:N), no CISA KEV entry exists, and the vendor advisory describes a proof-of-concept procedure that is not confirmed as publicly available working exploit code.
Server-side request forgery in Frappe Builder before 1.36.1 lets any authenticated user, including a Website User with no Builder access at all, drive the server-side image converter to fetch arbitrary URLs. Because the convert_to_webp handler performs a requests.get that follows redirects without re-validating the resolved IP, an attacker-supplied image_url can point at internal hosts or cloud metadata endpoints, and any response that decodes as an image is written to a world-readable /files/ URL the caller receives back - turning blind port probing into real data exfiltration. Exploitation requires a valid low-privilege session (PR:L in the CVSS vector), no user interaction, and default configurations are affected; no public exploit code has been identified at time of analysis and the issue is not in CISA KEV. The same advisory notes a path-traversal component via a /builder_assets/../ path and an overwrite hazard for existing public files, so the fix in 1.36.1 is broader than the SSRF itself.
Information disclosure in NocoDB through 2026.07.0 arises in the sign-in endpoint's AuthService.validateUser handling of the salt argument, enabling remote attackers to expose limited confidential data. Per the CVSS vector the issue is network-reachable and unauthenticated with no user interaction, but high attack complexity, a rating of difficult exploitability, and low-only confidentiality impact make this a moderate, lower-priority issue rather than an urgent one. No public exploit was identified at time of analysis, and no CISA KEV entry indicates active exploitation.
Concurrent requests against the NocoDB registration flow can subvert intended registration logic, yielding a low-integrity impact rather than any loss of confidentiality or availability (assessed CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N). The flaw is a race condition (CWE-362) in users.service.ts within the Registration component, affecting NocoDB releases up to and including 2026.08.0; exploitation is remote, needs no credentials or user interaction, but is rated highly complex and of 'difficult' exploitability because reliable triggering depends on precise concurrent timing. There is no CISA KEV listing and no public exploit identified at time of analysis, and no EPSS score was supplied; the vendor deleted the original GitHub issue without explanation and did not respond to early email contact, so no vendor patch or advisory is currently identified. One source tags the issue as information disclosure, but the assessed vector records no confidentiality impact, so that characterization should not be relied upon.
Memory exhaustion denial of service in ONNX prior to 1.22.0: the Python tensor-materialization helpers _unpack_2bit() and _unpack_4bit() resize unpacked arrays to the attacker-declared TensorProto.dims without first verifying that the packed payload actually encodes that many elements, so a tiny model can force a disproportionately large allocation. Applications that call onnx.numpy_helper.to_array() or construct onnx.reference.ReferenceEvaluator with an untrusted UINT2, INT2, UINT4, INT4, or FLOAT4E2M1 tensor (stored in raw_data or packed int32_data) are affected; a 66-byte model declaring 700,000,000 elements allocated roughly 700 MB on vulnerable versions. Merely loading the model, running onnx.checker.check_model(), or running shape inference does not trigger it - the initializer must be materialized. The vendor-rated CVSS vector is AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (6.2, Medium), consistent with a local library/file boundary; no public exploit code or active exploitation is reported in the available data, and the issue is fixed in 1.22.0.
Shape inference in the ONNX library (versions 1.4.0 through 1.21.0) mishandles the required Scan attribute num_scan_inputs: an absent attribute is dereferenced as a null pointer, and a negative value is narrowed to an oversized size_t that reaches a vector allocation and raises std::length_error, letting a crafted model crash or disrupt any process that runs onnx.shape_inference.infer_shapes on untrusted input. Only denial of service is demonstrated (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 6.2); the attack is unauthenticated but local in vector terms, since the attacker must deliver the model across the library's API or file boundary rather than over a network stack that ONNX itself exposes. No public exploit code or CISA KEV entry was identified at time of analysis, and the priority decision is 'this_month' - a routine patch rather than an emergency; note that the negative-value model passes onnx.checker.check_model(), so using check_model() as a pre-inference gate does not protect against this issue.
Out-of-bounds read in ONNX ConvTranspose shape inference (convTransposeShapeInference and convTransposeShapeInference_opset11) lets a crafted model terminate the hosting process, causing denial of service. The issue affects ONNX 1.2.1 through 1.21.0 and is triggered when an application calls onnx.shape_inference.infer_shapes() on an attacker-supplied model containing a ConvTranspose node whose weight tensor (input 1) has fewer than three dimensions and no kernel_shape attribute; such a model still passes onnx.checker.check_model(), so that validation does not block it. Severity is assessed at CVSS 3.1 6.2 (AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) with availability-only impact and no demonstrated confidentiality or integrity effect; no public exploit has been identified at time of analysis, and the issue is fixed in ONNX 1.22.0.
Out-of-bounds read in ONNX's legacy shape-inference path allows an attacker-supplied model to crash a process that calls onnx.shape_inference.infer_shapes(). The vulnerable code, RNNShapeInference_opset1_to_6(), reads dim(0) and dim(1) from the first input of RNN/LSTM nodes (opsets 1-6) and GRU nodes (opsets 3-6) without verifying the tensor has rank three, so a malformed but checker-valid model triggers a protobuf repeated-field over-read and SIGSEGV. All ONNX releases through 1.21.0 are affected and the issue is fixed in 1.22.0; impact is limited to process termination (denial of service) with no demonstrated confidentiality or integrity effect, and no public exploit has been identified at time of analysis.
Memory corruption in Apple's mobile and desktop operating systems (iOS/iPadOS, macOS, tvOS, visionOS, watchOS) allows an app already executing on the device to trigger a buffer overflow that terminates the system or corrupts process memory. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N, C:N/I:L/A:H) confirms a local attack path with low privileges and no user interaction, so the practical gate is getting an app onto the target device; there is no confidentiality impact. No public exploit has been identified at time of analysis, EPSS is only 0.22% (12th percentile) and CISA SSVC records exploitation as none with automatable: no, so this is a moderate-severity, patch-on-normal-cadence item rather than an emergency.
Reflected cross-site scripting in Esri Portal for ArcGIS 12.1 and earlier allows a remote, unauthenticated attacker to craft a link that, when clicked by a victim, executes arbitrary JavaScript in that victim's browser context. Rated CVSS 6.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, CWE-79), the flaw requires victim interaction - the attacker-supplied link must actually be clicked - and the resulting impact is confined to the low-privilege browser session rather than server-side compromise. There is no CISA KEV entry and no public exploit identified at time of analysis; Esri rates the issue as a this-month priority rather than an emergency, reflecting a genuine but non-urgent patching task for administrators running the affected Portal versions.
Stored cross-site scripting in Esri ArcGIS Server 11.1 and earlier on Windows and Linux lets a remote unauthenticated attacker in certain susceptible configurations store files containing malicious code that then executes in a victim's browser when that content is loaded, requiring victim interaction (CVSS 3.1 base 6.1, AV:N/AC:L/PR:N/UI:R/S:C). Impact is confined to the victim's browser session rather than the server itself, and exploitation depends on a non-default or specific configuration whose exact upload path or enabling setting is not described in available sources. No public exploit code or confirmed active exploitation is identified, and the vendor has issued patches in the October 2026 ArcGIS security bulletin for the 12.1, 12.0, 11.5, 11.3, and 11.1 branches.
Reflected cross-site scripting (CWE-79) in Esri Portal for ArcGIS 12.1 and earlier allows a remote, unauthenticated attacker to craft a link that, when clicked by a victim, can execute arbitrary JavaScript in that victim's browser context. The CVSS 3.1 base score is 6.1 (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N): the attack is network-delivered and requires no attacker credentials, but success depends entirely on user interaction, and impact is bounded by a scope change with low confidentiality and integrity effects and no availability impact. No public exploit code or active exploitation has been identified at time of analysis, and Esri has published a patched ArcGIS Server 11.5 line for versions in General Availability and Extended support.
Post-authentication open redirect in nforwardauth through 1.5.0 lets an unauthenticated attacker craft a legitimate-looking /login?r= URL that sends a victim to an attacker-controlled site after a successful login. The vendor advisory, pull request #71 and the v1.5.1 release confirm both the flaw and its fix, and the advisory includes a public proof-of-concept that reproduces the server-side 307 Location redirect. Exploitation requires the victim to follow the crafted link and complete authentication (UI:R), so the impact is limited to phishing and social-engineering leverage on a trusted authentication domain; the vendor explicitly states this is not a ForwardAuth authentication bypass. No public exploit code beyond that advisory PoC and no active exploitation are indicated in the available data.
Credential leakage in Erlang hackney before 4.9.0 can expose HTTP basic_auth and cookie values when an application enables follow_redirect and a server returns a same-host redirect that changes scheme or port. The redirect handling compared only the hostname, so an https-to-http downgrade resent Authorization and Cookie headers in cleartext for an on-path attacker, while a same-host port change handed them to another service. The independent assessment rates this as medium severity (CVSS:3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N); no public exploit was identified at time of analysis.
Memory-exhaustion denial of service in Autobahn Python 26.7.1 through 26.10.0 (pip package `autobahn`) lets a remote, unauthenticated WebSocket client exhaust server memory by sending one tiny, highly compressed permessage-brotli frame; the decompressor inflates the whole frame before the configured maxMessagePayloadSize is enforced, so a 421-byte frame drove peak RSS to roughly 545 MiB under a 1 MiB message limit in the reporter's own measurement. Only servers that deliberately opt into the permessage-brotli extension (via the `compress` extra) are exposed - permessage-deflate, -bzip2 and -snappy already honor the output budget and are explicitly out of scope - and the impact is availability only, with no confidentiality or integrity exposure. Fixed in 26.10.1; a working proof-of-concept ships with the upstream advisory, no active exploitation is reported (EPSS 0.43%, 37th percentile), and the vuln.today priority is 'this_month' given the opt-in prerequisite.
Unchecked range validation in snappy-java (org.xerial.snappy:snappy-java) prior to 1.1.10.9 lets caller-supplied offsets and lengths reach a native memcpy, so negative or oversized byteLength/offset values can read or write outside Java array bounds and crash the JVM. Unauthenticated remote attackers can only reach the flaw if the embedding application forwards attacker-influenced ranges into Snappy.arrayCopy, SnappyInputStream.rawRead/read, or SnappyOutputStream.rawWrite/write (including typed-array variants), which is why the assessed vector is AV:N/AC:H with availability-only impact. There is no CISA KEV listing and no public exploit identified at time of analysis; EPSS is low at 0.41% (35th percentile) and the vendor has released 1.1.10.9 as the complete fix.
Recovery of a long-term X25519 private key is possible in erlang-jose 1.10.0 through 1.11.12 whenever the pure-Erlang Curve25519 fallback is the code path actually in use, because scalar multiplication there runs in secret-dependent time and lets an attacker who can submit ECDH-ES JWE ciphertexts and measure decryption timing reconstruct the private scalar bit by bit. The assessed impact is confidentiality-only (CVSS:3.1 AV:N/AC:H/PR:N/UI:N/C:H/I:N/A:N) and depends on a service that reuses a fixed X25519 key being reachable by an attacker able to collect large numbers of low-noise timing samples, so this is a conditional cryptographic weakness rather than an opportunistic mass-exploitation issue. A public PoC reference exists in the vendor advisory - a demonstration script that forces crypto_fallback and shows a stable timing delta between two victims differing only in their private scalar - but it is not verified as working key-recovery exploit code; there is no CISA KEV listing and EPSS is 0.14% (3rd percentile).
The Erlang/Elixir JOSE library (potatosalad/erlang-jose) can be driven into an unbounded tail-recursive loop through JOSE.JWK.shared_secret/2 when an application derives an ECDH shared secret from an attacker-supplied peer JWK whose key type differs from the application's own key. A single mismatched JWK (for example an RSA public key submitted to a server holding an EC P-256 key) never returns and never crashes, pinning one BEAM scheduler at 100% CPU; repeated submissions exhaust schedulers and degrade or take down the service. Only deployments on jose 1.5.0 through 1.11.12 that actually call shared_secret/2 on untrusted input are reachable - applications using jose purely for JWS/JWE/JWT signing and verification do not hit the vulnerable clause. Severity is a genuine but modest-priority availability issue: EPSS is 0.14% (3rd percentile), there is no CISA KEV listing, priority is 'this_month', but a public proof-of-concept script published with the vendor advisory demonstrates the scheduler hang. Fixed in 1.11.13.
Authentication-tag forgery in the Erlang JOSE library (jose 1.2.0 through 1.11.12) lets an unauthenticated remote attacker defeat AES-GCM integrity wherever decryption routes through the pure-Erlang jose_jwa_aes fallback - FIPS builds, or stripped or older OTP releases where :crypto does not expose a native AES-GCM NIF. Because verification compares only as many bits of the real 128-bit tag as the attacker-supplied tag contains, truncating the tag to a single byte drops forgery resistance to 2^-8, so a forged JWE with attacker-chosen ciphertext is accepted within 256 attempts without knowledge of the key; an over-length tag instead triggers a badmatch that crashes the decrypting process. A public PoC reference exists (advisory-attached Elixir script); it is not verified as working exploit code, there is no confirmed active exploitation (not in CISA KEV), and EPSS is 0.11% (2nd percentile), consistent with the conditional fallback prerequisite.
Bleichenbacher padding-oracle weakness in erlang-jose's pure-Erlang RSAES-PKCS1-v1_5 decryption (jose 1.3.0 through before 1.11.13) can let an unauthenticated attacker who knows only the public RSA key recover plaintext from intercepted RSA1_5 JWE content-encryption keys via roughly 10^4 to 10^6 adaptive chosen-ciphertext queries. Exploitation requires an application that unwraps RSA1_5 JWE keys with jose and exposes the decryption outcome, either as distinguishable return values (recovered key versus error) or as observable timing; the direct return-value oracle applies when the pure-Erlang jose_jwa_pkcs1 backend is active. No CISA KEV entry or confirmed active exploitation was identified, EPSS is 0.09%, and a public PoC reference exists but it is not verified as working exploit code.
Easy Digital Downloads, the WordPress e-commerce plugin from Awesome Motive, mishandles synchronization of a shared resource in versions through 3.7.1, creating a race condition (CWE-362) that a remote attacker can use to corrupt data the plugin is expected to keep consistent. The assessed vector (CVSS 5.9, AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N) means no authentication or user interaction is needed, but the attacker must repeatedly hit a non-deterministic concurrency window, so exploitation is timing-dependent rather than reliable on a single request; impact is limited to integrity, with no confidentiality or availability effect. No public exploit code or active exploitation is identified in the available data at time of analysis, and the exact vulnerable operation and endpoint are not described in the sources.
Stored and reflected cross-site scripting in OPNsense Firewall 26.7.1_1 and earlier lets an authenticated low-privileged GUI user execute JavaScript in another user's browser, including a root user's session, when the victim views the Dashboard, Interfaces → Overview, or submits a crafted Firewall → Log Files → Live View search. The stored variant requires write access to the Interfaces → Assignments Description field, while the reflected variant requires the victim to interact with the Live View search; both require valid GUI credentials and victim interaction. The issue is rated CVSS 5.6, no KEV status was provided, and a public PoC reference exists but is not verified as working exploit code.
Path traversal (CWE-22) in halo-dev Halo CMS through 2.27.0-beta.1 lets unauthenticated remote attackers manipulate the 'template' argument handled by DefaultViewNameResolver.resolveViewNameOrDefault, allowing traversal outside the intended theme view-name lookup and limited exposure or manipulation of files reachable by the Halo process; the reporter rates confidentiality, integrity and availability impact as Low, consistent with constrained file access rather than arbitrary full-path read or code execution. The CVSS 4.0 score is 6.9 with AV:N/AC:L/AT:N/PR:N/UI:N, and the vector carries E:P, so a public PoC reference exists; it is not verified as working exploit code, and there is no CISA KEV listing indicating active exploitation. The vendor was contacted about the disclosure and did not respond, and no vendor-released patch was identified at time of analysis, so exposure should be treated as ongoing for deployments on affected builds.
Information disclosure in Lobster_pro affects version 4.12.12-LTS and potentially other releases prior to 25.1.3, where improper permission checks let an authenticated low-privilege user on an adjacent network reach HTTP endpoints reserved for administrators. The assessed impact is confidentiality-only, with high disclosure of both the vulnerable component and dependent systems but no integrity or availability effect; the CVSS 4.0 base score is 5.6, and no public exploit was identified at time of analysis. It is a medium-severity, moderate-priority issue (this_month) rather than an emergency.
gssproxy can be persistently crashed by any local user who can reach its Unix domain socket: a GSSX_INIT_SEC_CONTEXT request that omits the target_name field triggers a NULL pointer dereference in the daemon. The issue affects gssproxy deployments on Red Hat Enterprise Linux 7, 8, 9, and 10 and is listed for Red Hat OpenShift Container Platform 4; because gssproxy does not automatically restart, Kerberized NFS and IdM services that depend on it can be disrupted until an administrator intervenes. No public exploit identified at time of analysis.
OS command injection in QuantGeekDev docker-mcp 0.1.0 and 0.2.0 allows an attacker who can influence the project_name argument to inject arbitrary shell commands through the Windows-specific command builder in docker_executor.py. The vulnerable path is exercised only on Windows deployments, and the CVSS UI:P component means a user or agent must invoke the affected MCP tool before the payload is assembled, so it does not fire passively. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; the vendor's CVSS 4.0 base score is 5.3, while our independent assessment rates it higher (7.5-equivalent impact under CVSS 3.1) because successful injection yields full command execution.
UI spoofing in Firefox for iOS before version 156.1 lets a malicious page open a 'tel:' link inside a window that is still displaying a different website, so the phone-call confirmation prompt appears to come from that trusted site. The attacker must first lure the victim into loading the malicious page and then persuade them to approve the dial prompt, so no silent action or code execution occurs; the assessed impact is integrity-only with no confidentiality or availability loss. Mozilla fixed the issue in Firefox for iOS 156.1 (MFSA2026-117); no public exploit code is identified and EPSS is low at 0.21%, with CISA SSVC rating exploitation as none.
Firefox for iOS versions before 156.1 could be made to display attacker-supplied text inside the system FaceTime call prompt, creating a UI-spoofing (CWE-451) vector for phishing messages presented as trusted Apple system UI. Only users browsing with Firefox for iOS rather than Safari and visiting a malicious page are affected, and the deception still depends on the user acting on the spoofed prompt; there is no code execution or data theft, and updating to Firefox for iOS 156.1 removes the issue. No public exploit code and no active exploitation are indicated (EPSS roughly 0.21%, SSVC exploitation: none), so this warrants routine patching rather than emergency response.
LearnPress through 4.4.11 contains a missing-authorization flaw (CWE-862, CVSS 5.4) that lets an authenticated low-privilege user perform actions outside their intended role, with limited confidentiality and integrity impact and no availability impact. The priority signal is this_month, no public exploit identified at time of analysis, and no CISA KEV entry is present, so this is a moderate rather than urgent issue; a valid account is required, although open LMS self-registration can make obtaining one easier.