NULL pointer dereference in sniproxy through 0.7.0 lets remote unauthenticated attackers crash the daemon by sending a 254- or 255-character TLS SNI name or HTTP Host header that matches a wildcard backend, then closing the connection while asynchronous DNS resolution is still in flight. Impact is availability-only - the proxy terminates with no confidentiality or integrity exposure and no code execution path. Exploitation is configuration-dependent: the deployment must have a wildcard backend that triggers asynchronous resolution for attacker-supplied names and must expose the TLS/HTTP listener to the attacker; no public exploit code was identified at time of analysis, and the case is not in CISA KEV.
Arbitrary deletion of WordPress core database tables is possible through the Database Cleaner plugin in all versions up to and including 1.4.7, because the plugin's table-deletion REST endpoint does not restrict which tables may be targeted. Rated CVSS 8.7 with a scope change (C:N/I:H/A:H), the flaw nonetheless requires the attacker to already hold Administrator-level credentials, so realistic risk is confined to sites with multiple, delegated, or potentially compromised admin accounts rather than default single-admin deployments. No public exploit code has been identified at time of analysis and there is no CISA KEV listing; priority is this_week rather than emergency.
Remote code execution in Paperclip AI server versions 2026.403.0 through 2026.416.0: an attacker who can call PATCH /api/execution-workspaces/:id can store an arbitrary cleanupCommand (or teardownCommand), which the server later runs through a shell as the Paperclip process when the workspace is archived. The CVSS 4.0 vector rates it 8.7 with PR:L, but the practical bar is far lower on default desktop installs - in local_trusted mode every request to 127.0.0.1:3100 is auto-granted instance-admin with no authentication and the board-mutation guard is bypassed, while in authenticated mode any user with company access qualifies because the company-access check runs after the database query. This is a genuine high-priority issue rather than an inflated-CVSS artifact; the vendor advisory ships a public proof-of-concept script (file write, systeminfo exfiltration, calc.exe launch on Windows 11), though this analysis has not independently verified that script as working exploit code, and there is no CISA KEV entry indicating confirmed active exploitation.
Songloft 2.9.0 through 2.13.5 ships an embedded Go backend that falls back to the fixed credential pair admin/admin whenever the administrator username and password are omitted from configuration, letting anyone who can reach the service on the local network log in as administrator through /api/v1/auth/login. From that session an attacker can rewrite library and configuration settings and install JavaScript plugins that execute inside the bundled QuickJS runtime, giving code execution in the server context; the mobile/embedded startup path binds 0.0.0.0, which is what makes the service LAN-reachable in the first place. The issue is unauthenticated from the network perspective (CVSS:4.0 AV:A/AC:L/PR:N/UI:N, 8.7; assessed as CVSS:3.1 AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) and is bounded by two things: the attacker must be on an adjacent network, and operators who set a strong admin password are not affected. A public technical writeup describing the admin-takeover attack exists and is referenced by the CVE record, though it is not verified as working exploit code; vendor-released patch 2.13.6 is available and the priority label is this_week. No public exploit code is confirmed and the CVE is not listed as actively exploited (CISA KEV).
Unauthenticated SQL injection in CoreShop by CoreUnion through 1.5.5 lets remote attackers read member accounts and order records through the api/Agent/GetGoodsPageList endpoint. The controller appends the client-supplied 'order' value to a fixed ORDER BY string and hands it to SqlSugar, so crafted subqueries pass the ORM's field-name check and are executed by the database; extraction is blind (boolean- or time-based) because the results are never returned directly. No CISA KEV entry and no confirmed active exploitation are associated with this CVE at time of analysis, but a public technical writeup describing the injection exists and the vuln.today decision label is this_week, indicating remediation should be scheduled promptly.
Unauthenticated SQL injection in CoreShop through 1.5.5 allows remote attackers to read member accounts and order records by supplying a crafted 'order' value to the api/Good/GetGoodsPageList endpoint. The value is appended to the query's ORDER BY clause, and the evidence indicates injected subqueries slip past SqlSugar's field-name check, enabling boolean-based and time-based blind extraction even though query output is not directly reflected. The assessed impact is confidentiality-only (high read exposure, no integrity or availability effect), vendor patching is available as an upstream commit, and a public technical writeup describing the injection exists; it is not verified as working exploit code.
Privilege escalation in DataCap (devlive-community) through 2025.1.1 lets any authenticated user, including one who simply self-registered, take full control of the instance by sending a PUT request to /api/v1/user/allocationRole to assign the administrator role to their own account; the same gap extends to administrative role and menu management endpoints. Exploitation needs only a low-privileged account and network reach to the REST API, with no user interaction and no privileged credentials. A public technical writeup and source-level references describing the flaw exist, and no CISA KEV entry appears in the supplied data; the vulnerability is rated 8.7 (CVSS 4.0) and flagged for this-week prioritization.
Lago's acceptInvite GraphQL mutation (all versions through 1.55.0) issues a valid session JWT for a pre-existing account without verifying that account's password, so an attacker who already holds an organization-administrator role can invite a victim's email address, accept the invite with a password of their choosing, and receive a token that grants access to the victim's organizations, billing data, API keys and payment integrations. Exploitation is authenticated (CVSS 4.0 PR:L) and limited to organizations using the EMAIL_PASSWORD authentication method; SSO-backed organizations are not reachable through this path because the identity provider already validates the email claim, and no victim interaction is required. No public exploit code is confirmed at time of analysis, although a public research writeup describing the attack chain exists, and the vendor has published an upstream fix commit.
n8n workflow automation instances older than 2.42.6, 2.43.x before 2.43.3, and 3.x before 3.0.1 let an authenticated user with workflow-authoring rights escape the task runner isolation that normally constrains custom code. By creating, editing, or importing a workflow that names one of the deprecated hidden node types (Function, Function Item, or LangChain Code), that user can execute arbitrary JavaScript inside the n8n main process rather than in the sandboxed runner, giving full compromise of the application host process. Severity is high (CVSS 8.7, CWE-653) but exploitation requires a valid account plus workflow-authoring permission; no confirmed public exploit code has been identified at time of analysis, and vendor patches are available for all three branches, with the priority assessed as this week rather than an emergency.
Delta UFC500 chargers expose web server POST and PUT actions without authentication, allowing an attacker on the adjacent network to reboot the device and, if the configid can be brute-forced, set the service password and alter arbitrary settings. The flaw is a CWE-306 missing-authentication issue rated CVSS 8.7, with high confidentiality and integrity impact and lower availability impact; the independent assessment notes that network segmentation or isolating the charger management interface materially reduces realistic exposure. No public exploit identified at time of analysis, and the vuln.today decision label is this_week.
Delta UFC500 charging stations generate the Service-account password from fixed character positions of the device serial number, so anyone who can reach the charger's management interface on an adjacent network segment can reconstruct that password - or brute-force the small resulting keyspace - and log in without credentials. Successful login gives read and write access to sensitive configuration, including the OCPP backend the station connects to, so an attacker could redirect charging traffic or alter operational settings. The access vector is adjacent/local, not internet-wide remote, so exposure depends on whether the management plane is reachable from a shared site LAN, management VLAN or local wireless; no public exploit code was identified at time of analysis and the issue is not in CISA KEV, though DIVD rates it a this-week operational priority.
Cross-site scripting in the iOS auth/handler component of Firebase Authentication and Google Cloud Identity Platform (builds prior to 2026-08-14) lets a remote, unauthenticated attacker execute arbitrary JavaScript inside the authentication flow by supplying a crafted iOS bundle ID that the handler reflects without sanitization. The independent assessment rates it CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:L/A:N - scope-changed script execution with high confidentiality impact, but the attacker must first draw a victim into the manipulated auth flow, so it is not a fully autonomous drive-by. Exposure is confined to the iOS code path and to versions older than the 2026-08-14 fix; non-iOS clients and patched builds are not affected, and no public exploit has been identified at time of analysis.
Code execution at assembly load in Refitter-generated C# clients (CWE-94/CWE-116): a header parameter name taken from an OpenAPI description is emitted unescaped into a Refit [Header("...")] attribute, letting a crafted spec close the parameter list, method, interface and namespace and inject a top-level file class with a [ModuleInitializer] that .NET runs when the compiled assembly loads, even if the generated client is never called. Affected are Refitter releases prior to 2.1.2 (the behavior was reproduced on 2.0.0 with .NET 8), and exploitation requires a developer to generate and compile a client from an attacker-controlled or attacker-influenced OpenAPI description, which is why the assessed vector carries UI:R despite the 8.6 severity. The malicious header name survives Refitter's default OpenAPI validation (no --skip-validation needed), a public PoC reproduction harness (make_spec.py and reproduce.sh) is attached to GitHub advisory GHSA-58x9-vjvp-6mx8, and the supplied intelligence contains no CISA KEV entry for this issue.
Refitter, the .NET tool that generates C# Refit clients from OpenAPI descriptions, writes content-type keys from requestBody/responses content maps straight into Refit [Headers("Accept: <ct>", "Content-Type: <ct>")] attribute strings without escaping quotation marks, letting a crafted content-type key break out of the attribute, interface and namespace and inject a top-level file class whose [ModuleInitializer] method runs attacker code when the generated assembly loads. The hostile key survives Refitter's default OpenAPI validation, so --skip-validation is not required; behavior was verified on Refitter 2.0.0 with .NET 8, and all versions prior to 2.1.2 are in scope. Exploitation is not self-triggering: a developer must run Refitter on an attacker-influenced spec and compile the resulting client into an application (CVSS 4.0 UI:A / 3.1 UI:R), after which the injected code executes at process startup with no call to the generated client; there is no CISA KEV entry or confirmed active exploitation, and a public PoC reference (reproduce.sh, make_spec.py) is attached to the GitHub advisory but is not independently verified as working exploit code.
Code execution at assembly load in applications built from Refitter 2.0.0 and earlier: the generator copies each OpenAPI paths-object key verbatim into Refit route attributes such as [Get("...")] without escaping quotes or restricting characters, so a crafted single-line, slash-prefixed path can terminate the attribute string, the enclosing interface and namespace, inject a top-level file class carrying a [ModuleInitializer], and reopen the generated structure so the file still compiles. Anything that compiles the generated .cs into an application then runs the attacker's code at process startup, even if the generated client is never called. Exploitation requires the victim to generate and compile a client from an attacker-controlled or attacker-influenced spec (UI:R in the assessed vector, UI:A in the CVSS 4.0 vector); a public PoC reference (a reproduce script plus spec generator attached to the advisory) exists and is not verified as working exploit code. Fixed in 2.1.2; no confirmed active exploitation (CISA KEV) is reported.
Command injection in the SQLite command-line shell through 3.54.1 lets an attacker-planted dot-command hidden in a database's sqlite_schema.sql text be re-interpreted and executed as an OS command when a victim pipes `.recover` output back into sqlite3. Exploitation is not passive: it requires the victim to open a crafted database, run the `.recover` command against it, and feed the resulting script into another sqlite3 process, so commands run only with the victim's own privileges in a non-default administrative recovery workflow. No public exploit has been identified at time of analysis, but the flaw is rated 8.5 (assessed CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and, being a genuine context-dependent execution risk rather than a mass-exploitation emergency, is prioritized for remediation this week.
Authentication bypass in the Polish Social Insurance Institution (ZUS) Płatnik desktop client lets an attacker who can run or manipulate a client instance connected to the backend server skip the login verification step and authenticate as an arbitrary user without credentials. The flaw is rooted in client-side authentication (CWE-603), and the assessed vector is CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L - unauthenticated from a privileges standpoint, but gated by local access to a deployed, backend-connected client, which is the main exposure limiter; CERT-PL reports it as EUVD-2026-113776 and the vendor states it is fixed in metric 242 of version 10.02.002. No public exploit code or active exploitation has been identified at time of analysis, and the vuln.today decision label places remediation in this week's patch cycle rather than an emergency response.
Local privilege escalation in NovumOS allows an authenticated user with shell access to load a malicious .nv script that the Nova interpreter executes in Ring 0, giving unrestricted kernel-memory access and code execution at kernel privilege with scope change and high confidentiality, integrity and availability impact. The root cause is architectural rather than a memory-safety defect: Nova is not confined to a Ring 3 domain and no special feature toggle is required, so any loadable script runs with full kernel rights on versions at or before 0.23. A public PoC reference (a sample Nova script writing to kernel memory) is included in the GitHub advisory; it is not verified as working exploit code, there is no KEV listing, and exploitation is limited by the need for local access and the small installed base.
Command injection in OPNsense firmware management (fixed in 26.7.8 and 26.10) lets an authenticated user holding only the 'System: Firmware' privilege store a crafted firmware mirror URL through POST /api/core/firmware/set, which the backend later evaluates as shell code the next time firmware information is retrieved or the firmware WebUI page loads - resulting in arbitrary command execution with root privileges. A related sed-injection path lets the same restricted account disable package signature verification. The vendor advisory includes a full proof-of-concept reproduction on OPNsense Community Edition 26.7.7; a public PoC reference exists, it is not verified as working exploit code, and no active exploitation is confirmed at time of analysis.
Heap buffer overflow in Scribus before 1.6.7, in both the Mac PICT image data loader and the pct import plugin, lets a crafted .pict/.pct file whose declared width is inconsistent with its actual row data write past the end of a heap buffer when the image is placed or imported, crashing Scribus or potentially achieving code execution. The attack is local and gated on user interaction: the victim must actively open, place, or import the malicious image (no privileges required, no network-facing or unattended vector), and no public exploit has been identified at time of analysis. Version 1.6.7 addresses the flaw by bounding copy lengths and nibble-expansion loops against the real scanline and source buffer sizes.
Integer overflow in Scribus' TIFF tile loader (scimgdataloader_tiff) before 1.6.7 lets a crafted tiled TIFF corrupt heap memory when a user imports it into the application, crashing Scribus and potentially allowing code execution under the importing user's privileges. The flawed step is the 32-bit size calculation used to allocate the tile buffer (TILEWIDTH x TILELENGTH x sizeof(uint32_t)), so an attacker who supplies large tile width, height and sample values causes an undersized allocation that libtiff then fills with tile data. Triggering it is local and requires passive user interaction (CVSS:4.0 AV:L/PR:N/UI:P; assessed as CVSS:3.1 AV:L/AC:L/PR:N/UI:R), and while the heap corruption is confirmed by the upstream fix, reliable code execution depends on heap layout and is not demonstrated in the available sources; no public exploit was identified at time of analysis, and a vendor patch is available in Scribus 1.6.7.
A heap buffer overflow in Scribus 1.6.x before 1.6.7 lets a crafted PICT/PCT file corrupt process memory when it is opened or placed through the PICT image loader or the PCT import plugin. The root cause is an unchecked bytesPerLine value used as the memcpy length into a QImage scanline, so a file whose bytesPerLine exceeds the destination row size overflows the heap, crashing the application and potentially allowing code execution with the user's privileges. Exploitation requires the victim to open or import the malicious file (local attack, user interaction), and a public PoC reference exists via the VulnCheck advisory; it is not verified as working exploit code, and there is no CISA KEV confirmation of active exploitation.
Out-of-bounds heap reads and writes in Scribus's SVM import plugin (importsvm) before 1.6.7 can crash the application or potentially enable code execution when a user opens a crafted StarView Metafile whose bitmap and transparency-mask dimensions disagree. The issue is local and requires user interaction to import the malicious file, and no public exploit was identified at time of analysis. It is a moderate-priority file-parsing memory-corruption issue rather than a mass-exploitation emergency, and the vendor has released Scribus 1.6.7 with fixes for the affected parsing path.
Heap-based out-of-bounds write in Scribus's Micrografx Draw (.DRW) import plugin (importdrw) before 1.6.7 allows local attackers to corrupt memory when a victim imports a crafted DRW file, resulting in a crash or potentially code execution. The plugin uses an unvalidated y offset to select image scanlines while decoding bitmap data, so writes can occur past the allocated heap image buffer; the attack is file-driven and requires user interaction to import the malicious document. No public exploit code or active exploitation has been identified at the time of analysis, and the vendor fix is Scribus 1.6.7.
Heap out-of-bounds write in Scribus before 1.6.7 can be triggered when a user opens, imports, or places a crafted Photoshop PSD file that supplies channel-count values exceeding the real image channels or the loader's five-element component lookup array. This local, user-interaction-dependent flaw can crash Scribus and potentially execute code with the privileges of the user who opened the file; the fixed release is Scribus 1.6.7, and no public exploit was identified at time of analysis.
A heap buffer overflow in Blender's point cache loading path, driven by an integer overflow in ptcache_data_alloc(), affects all versions before 4.5.15 and 5.x releases before 5.2.3. An attacker who supplies a crafted point cache file with an abnormally large totpoint value alongside a .blend file can crash the application or execute code with the privileges of the user who opens it; the attack is local (AV:L) and requires the victim to open the attacker-supplied files (UI:P), with no authentication needed once the files are loaded. No public exploit code or active exploitation has been identified at time of analysis, and Blender has published fixes for both affected branches.
Heap memory corruption in SQLite's session extension can be triggered when an application calls sqlite3changeset_apply() (or apply_v2) on a crafted changeset, letting an attacker write past an undersized column-mask buffer, crashing the process or potentially achieving code execution under the privileges of the hosting application. Only SQLite builds earlier than 3.54.0 that were compiled with SQLITE_ENABLE_SESSION are affected; the vector is local (AV:L) with user interaction required, but no privileges are needed (PR:N) and there is no direct remote-network path, so exposure is limited to applications that ingest untrusted changesets. The vendor fixed the flaw in SQLite 3.54.0 (commit 64459c87cc702d600704fb77ee40ca1782398a52) and added a regression test that applies a 242-byte crafted changeset; no public exploit code has been identified at time of analysis.
Heap buffer overflow in SQLite's FTS5 full-text extension (all releases before 3.54.0) allows an attacker who supplies a crafted database file to write past a leaf-page buffer when the FTS5 secure-delete path processes a corrupted index, corrupting heap memory and potentially crashing the host application. Exploitation is not free-standing: it requires FTS5 to be compiled in, the non-default secure_delete pragma to be enabled, and the victim application to open the untrusted database and execute a DELETE against the poisoned FTS5 table - prerequisites that the independent assessment captures as a local vector with user interaction (CVSS 3.1 AV:L/AC:L/PR:N/UI:R/C:N/I:H/A:H), which is more constrained than the input CVSS 4.0 score of 8.5 (AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H). SQLite 3.54.0 contains the upstream fix; the supplied intelligence shows no CISA KEV entry and no confirmed working exploit code, and the vuln.today decision label is this_week.
Heap out-of-bounds memory access in Blender's .blend file parsing path (read_struct()) can crash Blender or potentially enable code execution when a victim opens a crafted file whose SDNA struct layout compares equal to the expected layout, causing the parser to skip size validation and process deliberately short data blocks. Blender before 4.5.15 and 5.x before 5.2.3 are affected; exploitation is local and requires user interaction to load the file, no public exploit identified at time of analysis, and vendor patches are available. The issue is a this-week priority within its local, file-opening context rather than an internet-facing emergency.
Heap-based buffer overflow in Blender's .blend thumbnail extractor (blender-thumbnailer and the Windows shell extension) allows memory corruption and potential code execution or crash when a crafted .blend file is previewed. The flaw is a 32-bit integer overflow in thumb_data_vertical_flip() that is driven by malicious TEST block dimensions in the file, producing an out-of-bounds write. Affected builds are Blender before 4.5.15 and 5.x before 5.2.3, with fixes released in 4.5.15 and 5.2.3; exploitation is local with passive user interaction (file preview) and no public exploit has been identified at time of analysis.
Heap buffer overflow in SQLite's FTS5 full-text extension, fixed in SQLite 3.54.0, lets an attacker who can write to and query a detail=none FTS5 table overflow the allocation used to merge prefix doclists, corrupting heap memory and crashing the process. Preconditions are narrow: a SQLite build that includes FTS5, a virtual table created with the non-default detail=none option, rows carrying negative rowids (the upstream regression test uses -9223372036854775808) and a prefix MATCH query such as 'a*' against that table; default builds without such a table are not exposed, and the input CVSS 4.0 vector is AV:L, matching the independent assessment of CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:H with availability impact dominant. No public exploit code has been identified at time of analysis and there is no CISA KEV listing; the vendor fix is already available, so remediation is scheduled for this week.
Cross-tenant object-store writes in SOCFortress CoPilot before 0.1.76 let any authenticated customer_user (customer-portal) account overwrite arbitrary objects in any bucket - including other tenants' case evidence and forensic artifacts, the Sysmon configuration distributed to managed Windows endpoints, and the report templates rendered server-side - because the upload route accepts caller-controlled bucket and object names with no allow-list, no tenant prefix, no ownership check and no content validation. The write is an unconditional upsert that creates missing buckets on demand, so the lowest-privilege role can blind endpoint telemetry, tamper with cross-tenant evidence, poison report templates for later server-side rendering, plant data or exhaust storage. The reporter published a confirmed live proof-of-concept with reproduction steps against the published ghcr.io/socfortress/copilot-backend:latest image; no CISA KEV entry or other active-exploitation reporting is present, and 0.1.76 fixes the issue by restricting the upload route to admin/analyst scopes.
Stored cross-site scripting in ManageEngine SharePoint Manager Plus before client build 4508 lets authenticated low-privilege users plant HTML or JavaScript in attributes used by the chart feature - users' full names, site names, and group names - which is stored and later executed in another user's browser when the affected chart is rendered. Exploitation is conditional: the attacker needs an account able to influence those fields, and the payload only fires when a victim loads the chart (UI:P), ideally a higher-privileged administrator. The vendor fixed the issue in build 4508; no public exploit was identified at time of analysis, and the vuln.today priority is this_week rather than act-now or emergency.
Arbitrary code execution in MONAI's Auto3DSeg component (versions 1.6.0 through 1.6.0rc1) lets a crafted work directory run attacker Python as soon as a victim loads it with AutoRunner() or import_bundle_algo_history(). The loader trusts an untrusted algo_object.json, prepending an attacker-supplied algorithm_templates directory to sys.path and instantiating its _target_ dotted name through monai.bundle.ConfigParser - and the advisory confirms this path works under default configuration with MONAI_ALLOW_PICKLE unset, unlike the gated .pkl branch. Exploitation is local and interaction-dependent (the victim must obtain and open the malicious artifact) and no authentication is needed; the vendor advisory publishes a proof-of-concept work-directory layout, though independent verification of working exploit code was not performed, and there is no confirmed active exploitation (no CISA KEV listing) and no EPSS figure supplied.
Improper access control in ESET Endpoint Encryption up to 5.4.23.0 and ESET Full Disk Encryption up to 2.4.4.0 on Windows allows a local standard user to open a device interface exposed by a privileged ESET kernel driver and submit specially crafted requests, resulting in high confidentiality, integrity and availability impact on the affected endpoint. The flaw is local only and requires an already-established low-privileged account (CVSS:4.0 PR:L, independently assessed as CVSS:3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.5), so exposure is confined to managed Windows endpoints running these encryption products below the fixed builds. No public exploit code or active exploitation is identified in the available data, and the vendor has published a fixed-build advisory (ESET ca9033).
jack prior to 0.1.0 serializes raw upstream FetchError objects into HTTP error responses, so an authenticated peer can read back the outbound request headers jack used - including the internal Radarr/Sonarr X-Api-Key and connector secrets such as CF-Access-Client-Secret. Exploitation requires only the shared peer API key sent as X-Api-Key (PR:L) plus valid Cloudflare Access service-token headers if the deployment is CF-Access gated; the attacker then forces an upstream non-2xx or schema-validation failure through GET /peer/items/:id or GET /servers/health (leaking the *arr key) or GET /torznab/download/:id (leaking another peer's key and CF Access secrets), with no race and no user interaction. The GitHub security advisory publishes detailed reproduction steps, but no confirmed working exploit tooling and no CISA KEV listing; the flaw is fixed in version 0.1.0 and carries a vendor-prioritized 'this week' remediation label.
OS command execution in CallBackery for Perl before 0.62.0 allows an attacker who can supply a configuration backup to run arbitrary commands as the application user when that backup is restored. The restoreConfigBlob() routine pipes the backup's database dump into the sqlite3 command-line shell, which executes dot-prefixed lines such as .shell, .system and .load as its own instructions instead of treating them as SQL data. The assessed vector (CVSS 8.4, AV:N/AC:L/PR:L/UI:N) means delivery can occur over the network but the attacker must hold the privileges needed to submit a backup and trigger its restoration; no public exploit has been identified at time of analysis, and vendor release 0.62.0 provides the fix.
SQL injection in ARKETEAM Protectel modules PROTECTELMAJ and BDF allows an authenticated user to submit crafted input through the profilInput parameter and alter database queries, with HIGH confidentiality and integrity impact and LOW availability impact. Affected releases are PROTECTELMAJ before 6.5.19 and BDF before 6.4.67; the vendor CVSS 4.0 score is 8.4 (High), and fixed versions have been released. The supplied vector indicates adjacent-network access and high privileges (AV:A/PR:H), while the advisory says a low-privileged user can trigger the flaw, so the privilege and network preconditions remain unresolved; no public exploit was identified at time of analysis.
SQL injection in the ARKETEAM Protectel modules PROTECTELMAJ (before 6.5.19) and BDF (before 6.4.67) allows an authenticated user with adjacent-network access to inject arbitrary SQL through the "Utilisateur" parameter, potentially reading and modifying database contents and affecting availability. The issue is CWE-89 and has vendor-released fixes; no public exploit code or confirmed active exploitation was identified at time of analysis. Exposure is limited by the need for a valid account and adjacent-network reachability, and the supplied privilege metric is inconsistent with the described low-privileged user requirement.
Cleartext storage of universal factory default passwords in the Delta UFC500 WebUI template database lets an authenticated attacker with low local privileges recover credentials for all five account types. The defaults are identical across devices and were unchanged on the tested unit, so recovered credentials can be reused on any unit where operators have not rotated them; the sources do not confirm whether those defaults are usable for network-facing WebUI login. No public exploit identified at time of analysis, and the priority label is this_week rather than an emergency or KEV-confirmed active-exploitation signal.
Broken object-level authorization in IXP Manager before 7.3.0 allows any authenticated user to view and edit another user's API-key record through the ApiKeyController edit/update path, which selects records by identifier without verifying that the caller's user_id matches. The flaw requires a valid account and a deployment with more than one user, and it is fixed in v7.3.0; this is a credible but not emergency-grade priority, with no public exploit code or active exploitation identified at time of analysis. The vendor states that upgrading to v7.3.0 should be applied as soon as possible.
The Forocoches comments editor allows any user holding a forum account with commenting privileges to embed an image whose source URL points at a server they control; when other users later open the affected discussion thread, their browsers automatically issue the HTTP/HTTPS request to that external host, disclosing the viewer's source IP address, User-Agent string, access timestamp and related request metadata to the attacker. The exposure is limited to that request metadata - no post content, credentials or session data is described as leaking - and it only occurs once a victim actually renders the thread, with no ability for the attacker to choose which users are hit. Affected builds are those prior to the May 2026 revision; no public exploit code or confirmed active exploitation was identified at the time of analysis, and the vendor notice is published by INCIBE (EUVD-2026-113760).
Unauthenticated attackers can crash the Traefik proxy process by repeatedly opening and aborting HTTP/1 protocol upgrades (such as WebSocket) against routes handled by the experimental FastProxy feature, which races on a shared bufio.Reader and eventually panics unrecovered. Only deployments that explicitly enable experimental.fastProxy in Traefik v3.2.0 through v3.7.14 are affected - default configurations, all Traefik v2 releases, and routes without an upgrade-capable backend are not. Exploitation is probabilistic and requires repeated attempts rather than a single request; no public exploit code is confirmed, and the flaw is not known to be actively exploited.
Improper authorization in the Filecoin Pin `upload-action` GitHub Action (versions ≤1.0.1, covering the entire 0.x line and 1.0.x) lets an external fork contributor get arbitrary artifacts produced by their pull request pinned to Filecoin using the repository owner's configured wallet, causing unauthorized storage expenditure, dataset pollution and drainage of wallet funds - without ever learning the wallet private key. The bypass only bites repositories that follow the documented two-workflow pattern, where an untrusted PR workflow builds an artifact and a privileged `workflow_run` workflow downloads and uploads it; the fork check in `upload-action/src/build.js` only inspects `event.pull_request`, which is absent on `workflow_run` events, so `isForkPR` evaluates to false and the upload is allowed to proceed. There is no CISA KEV entry and no confirmed working exploit; a public PoC reference (a sample event/simulation script) exists but is not verified as working exploit code, and no EPSS score was supplied. The vendor fixed the issue in 1.1.0 and explicitly will not backport to 0.x.
Insecure handling of the caller-supplied AWS Region string in aws-nitro-enclaves-sdk-c at or before v0.4.5 lets a local application on the parent EC2 instance impersonate the AWS KMS endpoint that a Nitro Enclave connects to, enabling injection of forged KMS responses into the enclave's requests. AWS states that only enclave applications which forward an unvalidated, externally supplied region into the library are affected; there is no cross-account or cross-tenant exposure and authentic KMS responses remain separately encrypted, so confidentiality is not impacted. The vendor has released v0.4.6 with an input validation fix, but customers must also rebuild their custom enclave images; no public exploit code or confirmed active exploitation was identified at time of analysis, and the issue is rated this_week priority rather than an emergency.
Kernel-stack corruption in FreeRTOS-Kernel V7.4.0 through V11.3.2 lets a local unprivileged task write attacker-controlled data past a pointer-sized object on the privileged kernel stack when an MPU-enabled port is combined with queue sets (configUSE_QUEUE_SETS=1), crossing the isolation boundary the FreeRTOS MPU is meant to enforce. Assessed impact is integrity-only and high (CVSS 3.1 AV:L/AC:L/PR:L/UI:N/S:C/C:N/I:H/A:N): the attacker must already be running as an unprivileged task on the device, and firmware built without queue sets is not affected. No public exploit was identified at time of analysis; the vendor shipped V11.3.3 as the fix.
Amazon Kinesis Producer Library for Java (KPL) 1.0.7 and earlier exposes the AWS credentials it resolves for the application to other accounts on the same host: the library hands those credentials to its native child process as command-line arguments, where any local user can read them from the process argument list, and when the Daemon logger runs at DEBUG it also writes them into the application log in hex-encoded form. Exploitation is strictly local and requires an existing account on the host (CVSS v3.1 AV:L/PR:L, vendor score 8.2), and no public exploit code was identified at time of analysis; the argument-list exposure applies to default configurations and cannot be configured away, while the log exposure is limited to DEBUG-level Daemon logging. AWS has released KPL 1.0.8, which sends credentials over IPC instead of the command line and changes the native-process debug logging, and recommends rotating any long-lived IAM keys and revoking active role sessions that may have been disclosed.
Cookie attribute injection in AdminNeo 4.6.0 through 5.5.0 lets an attacker who can influence the X-Forwarded-Prefix request header append arbitrary Domain, Path, Secure and SameSite directives to every Set-Cookie header AdminNeo emits, re-scoping the neo_sid session ID and the neo_key database-password encryption key to an attacker-controlled domain. Exploitation is conditional: the deployment must be one where a fronting reverse proxy (Traefik PathPrefixStrip, nginx or HAProxy) forwards the client-supplied header instead of a static trusted value, or the attacker must sit in an upstream-proxy or man-in-the-middle position, and a logged-in victim must subsequently issue requests so the tainted cookies reach the attacker (assessed CVSS 8.2, AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:L/A:N). Public proof-of-concept curl request examples are included in the vendor advisory but have not been independently verified as working exploit code, and there is no CISA KEV entry; the vendor-released patch is version 5.5.1, referenced by the vuln.today decision label 'this_week'.
Path traversal in praktor through v0.9.0 lets any Telegram user who can message the bot write files outside the intended uploads/ directory inside an agent's persistent workspace volume. Because the default configuration (telegram.allow_from: []) accepts all senders, no authentication or prior privilege is required: the attacker controls the uploaded document filename and can plant or overwrite CLAUDE.md, instruction, skill, hook, or configuration files that the Claude Code agent reads on later runs, yielding a stored instruction injection whose assessed impact is integrity-only (C:N/I:H/A:N). The issue is fixed in v0.9.1 via PR #228; no public exploit code was identified at time of analysis, although the reporter supplied the maintainers a private end-to-end proof of concept against the real container.Manager along with fix verification.
Pending deposits in Cardano Hydra heads can be stolen by any third party who can observe the chain and submit a standard Cardano transaction. Versions prior to 2.1.0 ship a deposit validator (hydra-plutus/validators/deposit.ak, deployed via hydra-node <= 2.0.0) whose Claim branch only compares the deposit datum's head_id to the attacker-supplied redeemer currencySymbol and checks the transaction is before the deposit deadline; it never requires the Head state-token UTxO to be spent and never constrains outputs, so a standalone Claim transaction confirming before the deadline redirects the deposited assets to an arbitrary address. The attack is unauthenticated and needs no victim interaction, only a deposit in flight through POST /commit and not yet past its deadline (default three times depositPeriod, typically tens of minutes to hours); the vendor advisory publishes a full exploit walkthrough and devnet reproduction, and the flaw is fixed in 2.1.0. No CISA KEV listing is present in the supplied data.