Stored cross-site scripting in the bPlugins 'B Slider' WordPress plugin (versions through 2.2.2) allows an authenticated low-privileged user to persist script payloads that execute in the browser of anyone who later views the rendered slider, carrying a CVSS 3.1 base score of 6.5 (AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:L). The flaw is only reachable where the plugin is installed and accounts with content-contribution privileges (contributor/author level) can submit or edit slider content, and the payload fires only when a victim with an active browser session loads the affected page - typically an administrator or editor, which is where the scope-changed impact becomes meaningful. No CISA KEV entry or public exploit code was identified at time of analysis; the vuln.today priority label is 'this_month' and the entry was reported through Patchstack.
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.
Reflected cross-site scripting in the 'max' argument of /book_flight.php in itsourcecode Airline Reservation System 1.0 allows attackers to execute script in a victim's browser session. The exploit is not authenticated (PR:N) but requires victim interaction (UI:P), so it is a targeted, social-engineering-dependent issue rather than a self-propagating or server-side compromise; impact is bounded to low integrity only, with no confidentiality or availability effect. A public PoC reference exists but it is not verified as working exploit code, EPSS is low at 0.35% (28th percentile), there is no KEV status, and the vuln.today decision label is 'monitor'.
Type confusion in the Lua sandbox of Sid Meier's Civilization IV 1.0.12.68 lets an attacker who convinces a player to load attacker-supplied content - a crafted mod, scenario/map, or save file - reach the loadstring function and corrupt the game's scripting state, producing limited confidentiality, integrity, and availability impact. No authentication is required (PR:N per both the CVE CVSS 4.0 vector and the assessed CVSS 3.1 vector), but the attacker has no silent trigger: the victim must actively choose to load the malicious file (UI:P/UI:R), and only that specific build is identified as affected. A public proof-of-concept reference exists (a GitHub repository with an Exploit.lua); it is not verified as working exploit code, there is no KEV listing, and the vulnerability-today decision label is 'this_month', indicating a genuine but modest priority rather than a top-tier emergency.
A type-confusion flaw in the Lua Sandbox of Civilization V 1.0.3.144 (function loadstring) lets remote attackers deliver crafted Lua content - a mod, map or scenario - that, once loaded by the victim, corrupts memory and can compromise confidentiality, integrity and availability of the game process. No authentication or privileges are required (CVSS 4.0 vector is PR:N), but the user must actively load the malicious content, which the independent assessment describes as a 'three-click' interaction flow; the reported CVSS 4.0 severity is 5.3 (medium) with Low impacts to each of C/I/A, while the independent CVSS 3.1 assessment rates all three as High. A public PoC reference exists (a VulDB entry and a blog plus GitHub exploit.lua linked from the advisory); it is not verified as working exploit code, and no CISA KEV listing or confirmed active exploitation is present in the supplied data. The vendor was contacted and did not respond, so no fixed version or official mitigation is available.
Server-side request forgery in the self-hosted bookmark manager Benotes (fr0tt benotes) through version 2.8.1 allows an authenticated, low-privileged user to make the server fetch an arbitrary URL they control through the bookmark metadata endpoint. Exploitation requires a valid account with access to the bookmark creation/metadata flow (CVSS PR:L) and only affects confidentiality at a low level, with no integrity, availability, or cross-system scope impact assessed; the overall severity is low (CVSS 4.0 score 2.1). A public PoC reference exists but is not verified as working exploit code, there is no CISA KEV listing, and the maintainer was notified via a GitHub issue but has not responded, so no vendor fix is currently identified.
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.
An authenticated low-privileged user of BKWLD Decoy through version 5.11.1 can raise their own privileges by manipulating the 'role' argument handled by the Authorization Policy logic in Policy.php. Because the attacker must already hold a valid account (CVSS PR:L), anonymous remote users cannot exploit it, but no user interaction is needed and the attack path is simple. This is a medium-severity integrity-only issue (CVSS 4.0 base 5.3; assessed CVSS 3.1 5.3, C:N/I:L/A:N) that sits below emergency priority; a public PoC reference exists but is not verified as working exploit code, there is no confirmed active exploitation, and the vendor did not respond to the disclosure.
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.
Authenticated price manipulation in Omega Solution Restro POS through 20261026 can corrupt sale-invoice business logic via the productUnitSalePrice argument, letting a low-privileged user alter invoice line values. The CVSS 4.0 base score is 2.1 and the independent CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N) confirms integrity-only impact with no confidentiality or availability effect; exploitation requires a low-privileged authenticated session on the application. A public PoC reference exists but is not verified as working exploit code, active exploitation is not confirmed in the provided data, and the vuln.today priority is monitor.
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.
Improper authorization in the backend component of Bdtask Garage 24 Garage Management Software 1.0 allows a remote user holding a low-privilege authenticated session to perform actions beyond their intended permissions, with limited confidentiality, integrity, and availability impact. The assessed vector requires valid authentication (PR:L) and shows no scope change, so the flaw is not reachable by fully unauthenticated attackers, and the specific backend feature or endpoint that triggers it is not described in the available sources. A public PoC reference exists but is not verified as working exploit code; the vendor did not respond to the disclosure, no fixed version is provided, and the current priority label is monitor, making this a low-priority issue despite being remotely reachable.
An authenticated low-privilege user of iFlytek astron-agent 1.1.2 and earlier can read knowledge-list data belonging to other spaces by tampering with the space-id argument on the Console Knowledge-List endpoint (FileInfoV2Service.listKnowledgeByPage). The flaw is an insecure direct object reference (CWE-639) with a CVSS 4.0 base score of 2.1 and only confidentiality impact; a public PoC reference exists, but it is not verified as working exploit code, and the vendor did not respond to the report. The available data does not identify a fixed release.
Code injection in AllenAI AllenNLP through 2.10.1 allows an attacker who controls the 'type' value in a configuration to drive unsafe reflective class instantiation through Registrable.resolve_class_name, potentially achieving code execution inside any host application that loads that configuration. Exposure is limited to deployments that pass untrusted FromParams-style configuration into the Registrable machinery and requires the victim to process the malicious config, so the library handling only trusted, local configurations is not affected. A public PoC reference exists (it is not verified as working exploit code), there is no CISA KEV entry, and the maintainer did not respond - the project is end-of-life, so no vendor fix is expected and the current priority is monitoring.
Improper authorization in JIZHICMS's front-end order handler (the Pay function in app/home/c/OrderController.php) allows a low-privileged authenticated user to supply an attacker-chosen orderno and act on orders belonging to other users, affecting releases up to and including 2.5.6. Exploitation requires a valid front-end account (CVSS 3.1 PR:L, AV:N, AC:L, UI:N) and is limited to low integrity impact with no confidentiality or availability effect. A public PoC reference exists; it is not verified as working exploit code, and no CISA KEV listing appears in the supplied intelligence, while the CVSS 4.0 vector carries E:P exploit maturity. The vendor was contacted about the disclosure and did not respond, and priority is set to this month's remediation cycle rather than immediate emergency action.
OS command injection in the Sed Command Filter component of Z.ai Zcode (versions up to and including 3.14.3/3.15.1) lets a remote attacker who already holds a low-privileged authenticated session push input into a shell invocation and obtain limited confidentiality, integrity and availability impact rather than full host takeover. The reporting source is VulDB and the vendor-facing reference scores it 5.3 under CVSS 4.0; a public PoC reference exists, but it is not verified as working exploit code, and there is no confirmed active exploitation (no CISA KEV listing). Risk is capped by the authentication prerequisite (PR:L in both the reported and independently assessed vectors), and the priority label is this_month rather than act_now.
Unrestricted file upload in GouGuOA through 6.1.2 lets an authenticated low-privilege user bypass upload extension restrictions and place a file of their choosing on the server through the disk module's chunkUpload API (app/disk/controller/Api.php). The CVSS 4.0 base score is 5.3 with PR:L and E:P, while the assessed CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects high confidentiality, integrity and availability impact once an account is held; no user interaction is needed. A public PoC reference exists in the form of a GitHub-hosted vulnerability report; it is not verified as working exploit code, and there is no KEV listing indicating active exploitation. The vendor was contacted and did not respond, so no fixed version has been published.
SQL injection in itsourcecode Online Cake Ordering System 1.0 lets a low-privilege authenticated remote user manipulate the ID argument of /deletetransac.php to alter database queries, with low confidentiality, integrity, and availability impact. A public PoC reference exists; it is not verified as working exploit code, and no active exploitation is confirmed. The issue is low-to-moderate and non-urgent, requiring a valid session and affecting a niche application with minimal real-world deployment.
Unrestricted file upload in SourceCodester Online Food Ordering System 1.0 allows an attacker holding a valid administrator session to upload arbitrary files through the 'image' argument of admin/add_food.php, potentially placing executable PHP content on the server. The precondition is significant: the CVSS vector carries PR:H, so a valid admin session on the admin interface is mandatory, which narrows realistic attackers to those who already hold or have compromised administrative credentials. Risk signals converge on low real-world priority - EPSS is 0.29% (22nd percentile), the vuln.today decision label is monitor, no KEV entry is present, and a public PoC reference exists but is not verified as working exploit code.
Stored cross-site scripting in Argilla 2.0 through 2.8.0 allows a user who can create or edit a dataset to inject script into the dataset Name field, which then executes in the browser of another user who opens that dataset's Settings page (SettingsInfo.vue). Because the injection point is the dataset name, an attacker needs an authenticated account with dataset-creation privileges (PR:L) and the victim must actually load the affected settings view (UI:P), which keeps the practical impact narrow; the CVSS 4.0 score is 2.0 and EPSS is only 0.25% (17th percentile), so the vulnerability is tracked as monitor priority. No vendor patch exists at time of analysis - Argilla was notified through GitHub issue #5875 and has not responded - and a public PoC reference exists; it is not verified as working exploit code.