Improper access control in ManageEngine Key Manager Plus builds prior to 7151 lets an authenticated user modify another user's ACME certificate deployment credentials, an integrity-only impact confined to that credential functionality. Exploitation requires a valid Key Manager Plus account (PR:L) on an unpatched build, and no public exploit identified at time of analysis. Our assessment rates the issue moderate: the CVE record's published 7.1 vector (AC:H, C:H, changed scope) is more severe than the assessed integrity-only impact, and the 'this_week' decision label places the upgrade in normal weekly remediation rather than emergency response.
Missing authorization in emailflare's inbox service lets any authenticated member - including the lowest-privileged member or tester role - list, create, and revoke API keys through the /api/keys routes. Because pre-fix key creation defaulted to 'global' scope, an attacker with a valid account could mint a live key accepted by /v1/send and send mail from any domain, or revoke existing keys to disable integrations. The flaw affects deployments running code before commit cf31f33; authentication is required (CVSS PR:L), and no public exploit was identified at time of analysis.
Stored cross-site scripting in HumHub's friendship confirmation dialog allows an authenticated member with only basic privileges to persist arbitrary HTML in their own first and last name, which then executes in the browser session of any other logged-in user who clicks the Friends button on that profile or People entry - including administrators. Only installations with the friendship system enabled and the display-name format built from first and last name are exposed, and the victim must actively click the button for the payload to fire; no self-triggering path exists. The flaw is fixed in HumHub 1.18.7 and 1.19.1, and no public exploit has been identified at time of analysis; severity signals place this in a high-but-conditional band rather than an emergency one.
Heap-based buffer overflow in Tanium Deploy allows an authenticated attacker who already holds high privileges on the service to potentially achieve full compromise of confidentiality, integrity, and availability. The flaw is network-reachable with low complexity and no user interaction once those privileges are held, but the assessed vector requires PR:H, so default unauthenticated external exploitation is not supported by the data. No public exploit was identified at time of analysis and there is no CISA KEV confirmation; the affected and fixed version boundaries are not stated in the available sources.
Authenticated administrative users on HPE Networking VIA can inject arbitrary operating-system commands and execute them with elevated privileges on the underlying host, with a CVSS score of 7.2. The issue is network-reachable, low-complexity, and requires no user interaction, but the PR:H vector means an attacker must first hold admin-level access to the management interface, making this a post-authentication privilege-to-OS escalation rather than an unauthenticated takeover. No public exploit was identified at the time of analysis.
Blind, time-based SQL injection in Chamilo LMS lets an authenticated administrator execute arbitrary SQL through the filters[groupOp] field of the get_sessions action in /main/inc/ajax/model.ajax.php, potentially exposing user, course, session, configuration, password-reset and administrative data, altering or deleting records within the database account's privileges, and causing denial of service via deliberately expensive delayed queries. All releases up to and including 2.0.0 are affected - the 1.x branch before 1.11.40 and the 2.x branch before 2.0.1. Exploitation requires a valid administrator session (CVSS PR:H), which is the principal limiting factor; no public exploit code was identified at time of analysis, and the issue is rated a this-week priority rather than an internet-facing emergency.
Authenticated TYPO3 backend users with mail-module access can view, change, send and export mails and recipient groups outside their assigned web mounts because the extension's backend actions and AJAX routes omit page-level authorization checks, exposing recipient personal data. The issue is rated CVSS 7.1 and affects the TYPO3 "mail" extension; exploitation requires a valid backend account with mail-module permissions, and no public exploit was identified at time of analysis.
Missing authorization in emailflare's POST /api/inbox/compose endpoint allows any authenticated user holding a 'member' or 'tester' role to set an arbitrary From address and have it passed unchecked into the Cloudflare send call, letting them send outbound mail impersonating other users or the organization to external recipients. Only outbound sender integrity is affected (integrity-only impact, CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N); administrators are not required, but the attacker must already hold a valid account on the instance. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; the practical exposure is further bounded because exploitation requires existing organizational access and the project is a niche, small-footprint deployment, making this a moderate this-week priority rather than an emergency.
Docker Sandboxes 0.31.0 through 0.49.x run host-side Git commands against a workspace repository whose Git configuration may have been written from inside a sandbox, allowing an attacker to plant a setting such as core.fsmonitor that Git later executes as a program on the host, outside the microVM boundary and with the invoking user's privileges. The attacker needs write access to the host repository's Git configuration - a direct-mode sandbox with that repository mounted read-write is the stated route - and the configured program only runs when the user subsequently performs a clone-mode fetch or, from version 0.39.0 onward, an sbx kit push. Docker fixed the issue in 0.50.0; no public exploit code has been identified at time of analysis.
Authenticated low-privilege users of HPE Networking Fabric Composer can exploit a broken authorization condition in its management API to read traffic from switches the product manages, exposing potentially sensitive network data. The flaw is rated CVSS 7.1 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N), with high confidentiality impact, limited integrity impact and no availability effect. No public exploit code has been identified at the time of analysis, and exploitation requires a valid low-privilege account plus network reachability to the Fabric Composer API.
Local privilege escalation in HPE Networking Fabric Composer allows an attacker who already holds a low-privileged local account to raise their privileges on the affected system through the product's API, compromising integrity and availability (CVSS 7.1, AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H). The flaw cannot be reached remotely or without an existing authenticated foothold, so the realistic exposure is limited to insiders or attackers who have already compromised a restricted account on a Composer host. No public exploit code or active exploitation has been identified at time of analysis, and the issue is tracked for remediation within this week's patch cycle.
Arbitrary file write in the HPE Aruba Virtual Intranet Access (VIA) client allows a local attacker holding only low-privileged access to escalate to higher privileges on the host, with no additional user interaction required once local access exists. The vendor rates this CVSS 7.1 (High) with vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N; our independent assessment concurs on the local, low-privilege precondition and adds a High availability impact. Exposure is limited to hosts where the VIA client is installed and where an attacker already has a local foothold, so remote exploitation is not possible; no public exploit code and no confirmed active exploitation (CISA KEV) are identified in the available data, and the vuln.today priority is this_week.
Path traversal in YETI's DFIQ import/export pipeline allows a low-privileged authenticated user to write attacker-controlled YAML content outside the intended temporary archive directory. Importing a DFIQ object whose `uuid` field carries traversal sequences through POST /api/v2/dfiq/from_yaml, then calling POST /api/v2/dfiq/to_archive, causes the service to create a `.yaml` file at an arbitrary path the YETI service account can write; the primitive is write-only and the filename suffix is forced. YETI releases prior to 2.5.1 are affected, the vendor advisory includes a proof-of-concept that was reproduced against an authorized lab instance, and there is no CISA KEV listing indicating active exploitation in real deployments.
The MongoDB C Driver fails to validate the type and format of the namespace field in a query response, so an unauthenticated MongoDB endpoint that a client chooses to connect to can return a malformed value, terminate the embedding application process via a reachable assertion (CWE-617), and induce an out-of-bounds read that causes a small amount of the application's own uninitialized heap memory to be echoed back to that endpoint in a follow-up command. Affected are applications that embed the C driver and connect to endpoints they do not fully control - a rogue server, an attacker-supplied connection target, or an on-path attacker impersonating a server; impact is confined to the single process embedding the driver (no scope change, confidentiality low, availability high). No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; the driver is reported as 'this_week' priority rather than an immediate emergency, and no fixed version is stated in the available advisory data.
In Red Hat OpenShift Container Platform 4 and 5 bare metal provisioning, the image-customization-controller runs an unauthenticated, non-TLS HTTP file server on port 8084 (default bind ":8084") whose root path returns a browsable directory listing of every registered per-host image. Any client that can reach the provisioning network can enumerate those image UUIDs, download an image, and pull the embedded Ignition config, recovering the base64-encoded cluster pull secret, the optional IRONIC_RAMDISK_SSH_KEY, proxy settings and per-host NetworkManager keyfiles. The vector is adjacent-network, no privileges and no user interaction (CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N), so confidentiality impact is the primary concern; exploitation requires an active provisioning cycle and network adjacency, and no public exploit code was identified at time of analysis. The unguessable-UUID filename was the only access control and the directory listing defeats it entirely.
Authorization bypass in LogChimp 0.9.0-alpha.1 through 0.9.2 allows authenticated post authors to overwrite other users' post title, slug, content, boardId and roadmap_id by sending a PATCH /api/v1/posts request with mismatched postId and id body parameters. The attacker sets postId to a post they own to pass the ownership check and id to an enumerated victim post UUID, which pre-fix was used as the actual update target; there is no confidentiality impact. The vendor fixed this in v0.9.3, no public exploit was identified at the time of analysis, and the priority is this_week - a genuine but not emergency-grade risk.
Plaintext secret disclosure in Dockhand 1.0.47 through 1.0.53 exposes stored stack secrets and values pulled from external providers (1Password, Bitwarden, HashiCorp Vault, Infisical, Doppler, Psono) to authenticated callers who either hold a Git stack's webhook secret or hold the stacks:start permission. The deployStack() result object carries a resolvedSecrets array, and three Git-stack endpoints - the webhook GET/POST, the manual deploy SSE stream, and create-with-'Deploy now' - return that object unfiltered, so the credentials also get persisted in Git forge delivery histories and printed into CI logs. Finsys fixed the leak in 1.0.54; no public exploit identified at time of analysis, and the 7.1 score reflects high confidentiality impact with no integrity or availability effect (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N).
SurrealDB builds before 3.3.0 abort the entire surreald process when an authenticated user with ordinary table write and read privileges accumulates a deeply nested val::Value one level per request and then triggers a read. The upstream advisory publishes a SQL proof-of-concept sequence (create a record holding an empty array, repeat UPDATE deep:1 SET v = [v] roughly 10,000+ times, then SELECT it) that drives native recursion past the ~8 MiB thread stack limit; because surrealdb-core is compiled with panic = 'abort', the resulting stack overflow is an unconditional process abort affecting every namespace, database and tenant on the instance. Beyond that advisory PoC sequence no public exploit code was identified at time of analysis, and the attack remains credential-gated and request-intensive; the aggravating factor is persistence, since the poisoned record survives restart and re-crashes every subsequent read and the admin EXPORT until it is purged out-of-band.
SurrealDB 2.0.0 through 3.3.0 does not enforce the --deny-funcs function-level security control on method-style function invocations, so an authenticated user who can submit queries can execute function families the operator explicitly denied - for example [1,2].map(...) instead of array::map(...), or $f.put()/$f.get() against a file bucket despite a file::* denial. The gap only exists on deployments that actually configure deny rules (--deny-funcs or SURREAL_DENY_FUNCS); the default 3.x streaming engine performs no capability check at all on this path, while the legacy compute-only path blocks some families and still lets others (math::abs, value::chain, array::any, array::sort::asc, type::string) through. Impact is highest when the experimental Files feature is enabled (3.3.x only) and bucket PERMISSIONS are permissive, allowing file bucket reads and writes under a deny file::* policy. There is no CISA KEV entry and no EPSS score was supplied, so active exploitation cannot be asserted; public reproduction scripts and transcripts are attached to the GHSA advisory.
Heap memory exhaustion in the FreeRDP proxy (versions 3.0.0 through 3.31.1) lets an authenticated client that already holds an RDP session through the proxy retain traffic-proportional heap by declaring a large DATA_FIRST length on an intercepted dynamic virtual channel and never completing the fragmented message. Only proxy deployments that actually enable DVC interception for an attacker-reachable channel are affected; the researcher's reproduction used a target-created AUDIO_INPUT channel with the shipped dyn-channel-dump module and measured roughly 6.55 MiB of retained data per incomplete message (ASan-inflated RSS figures were 324,012 KiB versus a 2,176 KiB control). Impact is availability only (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, CVSS 4.0 VA:H), no public exploit code was identified at time of analysis, and the issue is rated this_week rather than an emergency.
Any client that can authenticate to a FreeRDP shadow server (freerdp-shadow-cli) can abort the server process and drop every active session by joining the remdesk static virtual channel and writing an 8192-byte payload whose eight-byte header declares a total PDU length of eight. FreeRDP versions up to and including 3.32.1 are affected; 3.32.2 fixes the inverted completeness comparison and the buffer management across fragmented PDUs. Exploitation requires valid credentials and the remdesk channel to be joined (CVSS PR:L), and the abort has only been demonstrated on default assertion-enabled builds - source review shows an assert-disabled NDEBUG build falls through to a guarded channel error instead of crashing. Impact is availability-only: no memory corruption, information disclosure, or code execution was demonstrated. No confirmed public exploit code exists, though the vendor advisory publishes a working LD_PRELOAD reproducer, and there is no KEV listing for this CVE.
CPU exhaustion in FreeRDP's shadow server (through 3.32.1) lets an authenticated RDP client pin roughly one to two server CPU cores by sending drdynvc DATA PDUs that carry a valid dynamic-channel ID but zero application payload on the audin or rdpgfx channels; the shadow reader never consumes the zero-byte message and loops until the client disconnects. Only shadow-server deployments such as freerdp-shadow-cli are affected - not ordinary FreeRDP client installations - and because the stock xfreerdp client refuses to serialize a zero-length DVC write, exploitation requires a modified client or a post-serialization PDU shaper. There is no CISA KEV entry and no confirmed active exploitation; a public PoC reference exists in the form of the advisory's LD_PRELOAD shaper and loopback runner, but the input does not record it as confirmed working exploit code. No crash, memory corruption or data disclosure was demonstrated, and the advisory's own testing did not include a many-session exhaustion run.
Client-side denial of service in FreeRDP xfreerdp before 3.32.2 lets a malicious RDP server crash the connecting Linux X11 client by sending an RDPGFX ResetGraphics PDU with width zero followed by any ordinary bitmap update. The zero dimension passes the RDPGFX parser's bounds check, the resulting failed resize frees and nulls the GDI primary surface without ending the session, and the next bitmap paint dereferences the null pointer in gdi_Bitmap_Paint. Impact is confined to availability (CVSS 4.0 7.1; assessed 3.1 AV:N/AC:L/PR:N/UI:R/A:H with no C or I impact), the user must connect to the attacker-controlled server for exploitation, a public PoC reference exists in the GitHub advisory but is a callback-level harness not verified as working exploit code, and no KEV-listed active exploitation was reported.
CPU exhaustion in FreeRDP 3.32.1 and earlier allows a malicious or compromised RD Gateway to pin one client thread at 100% of a core by completing the RDG tunnel-open exchange and then sending an eight-byte keepalive control header that declares a 65,535-byte body which is never delivered. Only clients that explicitly connect through a gateway (the /gateway option with HTTP or WebSocket transport) are affected; direct RDP connections are not, and the victim must initiate the session, so the practical attack surface is users routed through an untrusted or machine-in-the-middled gateway. Impact is availability-only - the upstream advisory and reproduction confirm CPU spin and a runnable thread, not a crash, memory corruption, data access, or code execution - and the issue is fixed in FreeRDP 3.32.2. The upstream advisory (GHSA-x4x6-2hrm-hvq9) ships a complete proof-of-concept gateway harness that reproduces the spin, but the flaw is not listed in CISA KEV.
Denial of service in FreeRDP 3.17.0 through 3.32.1 can abort the client process when a malicious or relayed RDP server sends a crafted RemoteFX tile and the client is built with verbose WinPR assertions enabled. The abort occurs in the RemoteFX differential decoder and requires the victim to initiate the RDP connection and negotiate the classic RemoteFX surface-bits path; there is no confidentiality, integrity, or memory-corruption impact. A public proof-of-concept is included in the vendor advisory, and the issue is not listed in CISA KEV.
A malicious RDP server can abort a FreeRDP client that has RemoteFX surface decoding enabled by sending a crafted RemoteFX tileset whose RLGR bitstream encodes the value 32767, tripping a checked narrowing conversion in rfx_rlgr_decode and terminating the client process. Only denial of service to that single client process is demonstrated: the advisory explicitly reports no memory corruption, confidentiality or integrity impact, and no effect on other processes. Affected builds are FreeRDP 3.11.0 through 3.32.1 (fixed range ends before 3.32.2, per the published package metadata); the abort is additionally build-dependent because it only fires when the client is compiled with WITH_VERBOSE_WINPR_ASSERT enabled, which is the default in the inspected 3.32.1 CMake configuration but is disabled by some presets and downstream distributions. A complete public proof-of-concept relay script with a documented successful run is included in the upstream advisory; no confirmed active exploitation (CISA KEV) has been reported.
FreeRDP 3.x clients that decode classic RemoteFX graphics and were compiled with WITH_VERBOSE_WINPR_ASSERT=ON can be aborted by a malicious RDP server that sends a crafted RemoteFX region rectangle, giving the server a client-side denial of service (CWE-617 reachable assertion). The malformed rectangle uses x = 65535 while the RDP SurfaceBits destination starts at left = 1, so their sum no longer fits the 16-bit coordinate the client asserts on in rfx_process_message; builds made with verbose WinPR assertions disabled did not crash on the same packet in the vendor's testing, so real-world exposure is gated by build configuration. Exploitation requires a user to connect to an attacker-controlled or redirected RDP server and negotiate RemoteFX (UI:R, PR:N); impact is limited to loss of availability of the connecting client process, with no data, memory-corruption, server, or other-client impact. The issue is not recorded as actively exploited in CISA KEV, while the upstream advisory does publish a detailed loopback proof-of-concept relay script.
Client-side memory exhaustion in FreeRDP 3.0.0 through 3.32.1 lets a malicious or compromised RDP server force large allocations by declaring an enormous DRDYNVC DATA_FIRST Length, exhausting client memory and causing denial of service. The victim must connect to the server and have DRDYNVC negotiated with at least one dynamic virtual channel in DVC_CHANNEL_RUNNING state; the flaw does not provide code execution or data disclosure. A bounded public proof-of-concept reproducer is included in the advisory, but it is not verified as working exploit code, and no CISA KEV listing is provided.
Heap out-of-bounds read in µD3TN's BPv6/BPv7 fragmenter lets a local attacker with low privileges read process memory and reliably crash the bundle daemon (denial of service). A CVSS 3.1 vector of AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H (7.1, High) applies: the attacker must already hold a foothold on the host and be able to get input into the fragmentation code path, but no user interaction is needed, confidentiality and availability impacts are high, and integrity is unaffected. The CPE for d3tn_gmbh:µD3TN carries wildcard version components, so the vulnerable version range is not narrowed in the available data; no public exploit code and no CISA KEV entry were identified at time of analysis, and the only reference is the upstream GitLab work item 290.
Cross-user data disclosure in Instatic before 0.0.21 lets any authenticated user holding only the low-privileged ai.chat and content.edit.own capabilities read other users' private drafts and enumerate rows in the posts system table through the AI/MCP interface. The content_get_document, content_list_documents and content_search_documents tools call the underlying data-row helpers directly and never apply the object-level ownership checks that the normal HTTP data-row route enforces (that route correctly returns 404 for the same request). No content.edit.any, data.system.tables.read or ai.tools.write privilege is needed, and no LLM provider has to be configured because the /_instatic/mcp JSON-RPC endpoint can be called directly with an MCP bearer token; a public PoC reference (reproduction steps and screenshots against 0.0.20) exists in the upstream advisory, though it is not verified as working exploit code, and there is no indication of active exploitation.
Any registered user on HustOJ (versions 24.09.10 through 26.08.19) can delete, lock, or sticky any forum thread - including administrator announcements - because the thread-handling branch of threadadmin.php verifies only that a session exists, never thread authorship or administrative role. Successful abuse yields high integrity impact and partial availability impact on forum content (CVSS 7.1, I:H/A:L, C:N), requires no user interaction, and needs nothing more than a self-registered account on instances that allow open registration. There is no KEV listing and no confirmed working exploit code at time of analysis, though a public reference repository named for this CVE exists and is not verified as functional exploit code; an upstream fix is available in pull request #1192.
TYPO3 sites using the 'mail' extension's newsletter click-tracking can expose recipients' personal data to unauthenticated remote attackers. Requests to the click-tracking middleware that omit the recipient authentication code bypass the validation check, allowing data inserted into tracked newsletter links to be retrieved without credentials or user interaction. The vendor rates the issue medium severity (CVSS 4.0 base 6.9); exploitation is confined to installations that send tracked newsletters containing recipient data, and no public exploit identified at time of analysis.
An out-of-bounds write in TinyUSB's MTP device class helper mtp_container_get_string() (src/class/mtp/mtp.h) lets a malicious USB host corrupt adjacent memory on the device by supplying a crafted MTP string with an unchecked character count, with the resulting memory corruption potentially leading to code execution or a denial of service. Only firmware built through TinyUSB 0.21.0 that implements and exposes the MTP device class is affected, and because the attacker must control or substitute the USB host the device is attached to, exploitation requires physical USB access, though once that connection exists no authentication or user interaction is needed. The flaw is rated 7.0 (CVSS 4.0, full confidentiality/integrity/availability impact on the device), is fixed upstream by commit e85c2b8 with a vendor patch available, and is prioritized for remediation this week; no CISA KEV entry and no public exploit were identified at time of analysis.
Heap memory corruption in the check_icmp plugin shipped with Monitoring Plugins 3.0.0-rc1 through 3.0.0 gives a local low-privileged user an out-of-bounds write inside a process that still holds root privileges when check_icmp is installed setuid-root. Passing more than 65,535 hosts, either as repeated -H/--Host arguments or as Host= entries in an --extra-opts ini file, wraps an unsigned short host counter so process_arguments() allocates an undersized hosts array and writes later entries past its end, all before main() performs setuid(getuid()). This is a moderate, locally-scoped privilege-escalation risk rather than an urgent remote threat: there is no remote vector, reliable privilege escalation from the corruption has not been demonstrated, and no public exploit code was identified in the available sources; the fix is enforcing an explicit host-count bound.
Heap-based buffer overflow in the slurmstepd socket handling code of NVIDIA Slurm lets an authenticated local user corrupt heap memory, with the assessed CVSS 3.1 vector (AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.0) indicating high confidentiality, integrity, and availability impact. The affected product is captured by the wildcard CPE for nvidia:slurm, and no version-specific fixed release is present in the supplied data. No public exploit was identified at time of analysis, and the vuln.today decision label is this_week.
Denial of service in the Digital I/O function of Welotec TK100, TK500-v2 and TK500-v3 industrial routers lets a remote attacker who already holds high-privilege credentials crash or disrupt availability through insufficient bounds checking. The flaw is a buffer overflow class issue (CWE-120) with a CVSS 4.0 base score of 6.9; confidentiality and integrity are unaffected. No public exploit code was identified at time of analysis, and exploitation is constrained by the high-privilege authentication requirement.
Uninitialized-memory handling in the pybddisasm Python bindings can cause nd_to_text to turn an uninitialized output buffer into a Python return value when the underlying text conversion fails, potentially disclosing residual process memory or crashing the interpreter. The issue is locally scoped (AV:L) and requires low privileges (PR:L); exploitation depends on an application embedding the unmaintained package, passing input that makes conversion fail, and then returning or otherwise using the failed output. No public exploit identified at time of analysis, and the package is no longer maintained, so no vendor patch is expected and migration away from pybddisasm is the effective remediation.
A use-after-free in the pybddisasm Python bindings lets a local, low-privileged consumer of the library read freed heap memory or crash the Python interpreter when it keeps a reference to an element of an INSTRUX array member (such as an entry in the operands/ND_OPERAND list) after the owning INSTRUX object has been destroyed, because the child element does not keep the parent allocation alive. All versions of Bitdefender's pybddisasm package are affected (CPE cpe:2.3:a:bitdefender:pybddisasm:*), and the package is no longer maintained, so no vendor-released patch was identified at time of analysis. The trigger depends on the host application's own object-lifetime handling rather than on network input: no public exploit was identified at time of analysis, and the outcome is bounded to a likely process crash (availability) with only a limited memory-disclosure path (C:L), making this a medium-severity, low-urgency issue rather than a top priority.
Use-after-free in the unmaintained pybddisasm Python bindings lets a local, low-privileged process crash the Python interpreter or potentially read freed process memory when an application retains a structure-valued INSTRUX member reference after the parent object is freed. Exploitation requires a specific application coding pattern - obtaining a member object, letting the parent INSTRUX allocation be released, then accessing the stale member - and there is no remote or unauthenticated path. No public exploit has been identified at time of analysis, the package is no longer maintained, and the practical impact is limited by the narrow trigger and the library's small footprint.
Missing authentication on the POST /api/v2/oauth/authorize handler in NocoDB 0.300.0 through versions before 2026.08.0 lets remote attackers create OAuth authorization-code records with no associated user, because the route was guarded only by an authentication-optional global guard and carried no access-control decorator. The advisory is explicit that the flow never extends into a usable grant: the subsequent token exchange resolves the absent user to nothing and fails before any token is issued, so no access token can be obtained and no data is exposed through this path. Impact is therefore confined to unbounded ownerless authorization-code rows - bounded only by the endpoint's rate limiter - plus a server error where an authentication failure was appropriate; no public exploit identified at time of analysis, and the reported CVSS 4.0 score of 6.9 (our assessed CVSS 3.1 vector scores this as a low-integrity-impact issue) reflects a low-to-moderate priority rather than an account-compromise path.
Missing authorization in SourceHut's account service meta.sr.ht (versions 0.56.11 through 0.88.9) lets unauthenticated remote attackers create accounts on instances that have public registration disabled - the very control the flaw bypasses. An attacker first fetches a CSRF token from /login, then POSTs credentials to /register/step2, which reaches the RegisterAccount GraphQL mutation without the registration-enabled check, yielding unauthorized account creation with no confidentiality or availability impact. Scoring is split: the vendor/NVD-style CVSS 4.0 vector gives 6.9, while the assessed CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N (low integrity impact only); a public technical writeup of the bypass exists, but it is not verified as working exploit code, no CISA KEV entry or active exploitation is indicated, and priority is 'this_month'.
Password guessing against locked MiroTalk P2P meeting rooms is effectively unlimited in versions up to 2.0.87, because the pre-join 'checkPassword' Socket.IO handler in app/src/server.js compares the supplied password with a plain string equality check and keeps no attempt counter or lockout, letting unauthenticated remote attackers fire guesses at will and use the 'OK'/'KO' reply as an oracle. Exposure is narrow: the target room must actually be password-locked and its room ID known or discoverable, and success still depends on the room password being weak or guessable, which is why this is rated medium severity rather than urgent. A public PoC reference exists but is not verified as working exploit code, there is no confirmed active exploitation (CISA KEV), and the vendor has released a fix in 2.1.38.
Unauthenticated remote access to internal-use APIs in NetApp StorageGRID (formerly StorageGRID Webscale) exposes a limited set of grid-internal interfaces across all versions in default and common configurations, yielding low confidentiality and low integrity impact with no availability impact. The CVSS 4.0 score is 6.9 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N), and the vendor-set priority is this_month, so near-term remediation is appropriate rather than emergency response. No public exploit identified at time of analysis.
ZipUtil.unpack in zt-zip 1.18.0 and earlier can rewrite the permissions of the extraction output directory itself when an untrusted ZIP contains a self-referencing entry such as '/' or './' that carries attacker-chosen stored Unix mode bits. Applications that unpack attacker-supplied archives are affected; a restrictive output directory (for example owner-only) can be made readable, writable and executable by every local user, weakening the isolation of everything written under it. A public proof-of-concept snippet is included in the vendor's GitHub security advisory; it is not verified as working exploit code against third-party applications, and there is no CISA KEV confirmation, so active exploitation is not established. The vendor-released patch is zt-zip 1.18.1, and the project's priority label places this in the 'this month' remediation window rather than an emergency tier.
Unauthenticated application-name enumeration in Coolify (versions before 4.1.1) lets remote attackers list application names belonging to every team on an instance through the manual GitHub, GitLab, Bitbucket and Gitea webhook endpoints. Because the repository match runs before any webhook secret or signature check, submitting a full_name of '%' (or an empty value) together with a common branch such as 'main' turns the unescaped SQL LIKE wildcard into a match-all and returns the corresponding application names in the response payloads. Impact is limited to name disclosure - no source code, secrets or configuration are returned - and it requires that applications with a matching branch actually exist; the vendor CVSS 4.0 base score is 6.9, our independent assessment is 5.3 (CVSS 3.1), the fix is released in 4.1.1, and no public exploit or active exploitation has been reported.
Server-side request forgery and local file disclosure in Django's GeoDjango module affect 5.2 before 5.2.19, 6.0 before 6.0.10, and 6.1 before 6.1.3, where SpatialReference, the transform() methods on GEOSGeometry/OGRGeometry/GDALRaster, and the OGRGeometry.srs and GDALRaster.srs/srid setters forward attacker-influenced strings to GDAL without restricting its file and network access, letting unauthenticated remote attackers on an affected code path trigger outbound requests or read local files. Exposure is conditional: only applications that pass untrusted spatial-reference strings into these GIS APIs are reachable, and even after patching the file/network blocking is only enforced on GDAL 3.9 or newer. No public exploit code or active exploitation was identified at time of analysis; Django has released fixes in 6.1.3, 6.0.10, and 5.2.19.
Medium-severity server-side request forgery in Django's GeoDjango component allows unauthenticated remote attackers to make a vulnerable server send requests to attacker-selected destinations when crafted GeoJSON containing an external coordinate reference system (CRS) is passed to django.contrib.gis.gdal.OGRGeometry. Django 6.1 before 6.1.3, 6.0 before 6.0.10, and 5.2 before 5.2.19 are affected, while unsupported older series such as 5.1.x, 5.0.x, and 4.2.x were not evaluated and may also be affected. Vendor patches are available, and no public exploit was identified at time of analysis; practical exposure is limited to deployments that use GeoDjango with the GDAL backend and accept untrusted GeoJSON geometry input.
Log injection in Django's GeoDjango form layer lets remote attackers forge or corrupt application log entries by submitting a crafted geometry value to a form built on django.contrib.gis.forms.GeometryField, because BaseGeometryWidget.deserialize() wrote the rejected input into the django.contrib.gis error log without escaping control characters. Affected releases are Django 6.1 before 6.1.3, 6.0 before 6.0.10 and 5.2 before 5.2.19; older unsupported series (5.1.x, 5.0.x, 4.2.x) were not evaluated by the vendor and may also be affected. The CVSS 4.0 base score is 6.9, but the Django security team classifies the issue as low severity and the practical impact is confined to log integrity - newline or ANSI escape sequences can fake log lines or manipulate terminal output when such logs are viewed or ingested elsewhere. No public exploit code was identified at time of analysis.
Memory exhaustion in Django's MultiPartParser affects Django 6.1 before 6.1.3, 6.0.4 before 6.0.10, and 5.2.13 before 5.2.19 when an endpoint accepts multipart file uploads carrying Content-Transfer-Encoding: base64. Remote attackers can send such an upload without authentication or user interaction, causing the base64 content to be buffered entirely in memory regardless of FILE_UPLOAD_MAX_MEMORY_SIZE before upload handlers receive it. Impact is availability-only and rated low by the vendor; no public exploit is identified at time of analysis.
HDF5 through 2.2.0 reads past the end of the heap buffer holding an external link's user data when that link is traversed, because the default traversal callback H5L__extern_traverse() located the target file name and object path with strlen() without ever validating the payload against its recorded size. The flaw is reachable in default operation and requires a crafted HDF5 file whose external link data is not NULL-terminated or is too short to hold both strings; it triggers when a user or application opens an object through that link (CVSS 4.0 6.9, AV:L/PR:N/UI:P, availability high, confidentiality low). No public exploit code was identified at time of analysis and there is no KEV entry; the practical outcome is a crash/denial of service, with the additional possibility that adjacent heap bytes get folded into the file name or object path the library then attempts to open, and the upstream fix is the pull request referenced below (no released patched version independently confirmed).