Memory exhaustion in Pillow 8.1.0 through 12.x allows unauthenticated remote attackers to cause denial of service by supplying a crafted APNG that triggers a full-canvas background allocation inside Image.open() before the decompression-bomb check. The flaw is reachable when an application parses untrusted images with an affected version; no pixel loading, frame iteration, authentication, or user interaction is required. No public exploit code or CISA KEV entry was identified at time of analysis, but the availability impact is high (CVSS 8.7; assessed CVSS:3.1 A:H).
Information disclosure in Grav CMS 2.0.0 through 2.2.1 allows authenticated page editors to expose protected configuration - including security.salt, plugin credentials, and Redis passwords - to every visitor of the affected page by inserting config-*@ directives into a page's frontmatter form. The bypass defeats the Twig sandbox's config_denied_paths redaction, so values the CMS intends to keep internal are rendered into public page output. Our assessment rates this CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N rather than the advisory's 8.7 CVSS:4.0 vector, because exploitation requires an account already holding page-edit rights; no public exploit code or confirmed active exploitation was identified at time of analysis, and real-world impact depends on whether the deployment actually stores secrets in flat-file configuration.
Authenticated Control Panel users on Craft CMS 5.0.0 through 5.10.x can escape the Twig sandbox and achieve remote code execution by supplying uncleansed criteria to the getNext, getPrev, or getOwners element-query methods. The injected Yii 'as' or 'on' configuration keys attach a malicious behavior or event handler that executes as the web server user when the query runs. No public exploit code or CISA KEV entry was identified at time of analysis; the primary barrier is the requirement for a valid Control Panel account.
Denial of service in picomatch through 4.0.7: a malicious glob pattern such as +(*) or +(*a) compiles into a catastrophically backtracking regular expression that blocks the Node.js event loop and hangs the host application. The flaw sits in analyzeRepeatedExtglob in lib/parse.js, which skipped single-branch repeated extglobs and therefore missed the nested unbounded quantifiers that cause exponential blowup, so risk concentrates in applications that feed attacker-controlled glob patterns into picomatch or its consumers (micromatch, globby, chokidar) with extglob support left at its default. No public exploit code and no CISA KEV entry were identified at time of analysis, and an upstream fix is available as PR #194; fixed-pattern-only usage is not exploitable even though the assessed vector is PR:N/UI:N.
Remote code execution in Semaphore UI through 2.19.16 allows an authenticated user holding the task_runner role to escape the intended Ansible execution boundary by placing protected connection variables into a task's environment JSON. Supplying ansible_ssh_common_args with a ProxyCommand, or ansible_connection=local, makes Ansible run attacker-chosen commands as the Semaphore server process user, exposing encryption keys, SSH keys and other stored secrets. The project addressed the issue upstream in pull request #3888, but no tagged patched release number is stated in the available data, and no public exploit code was identified at time of analysis (CVSS 8.7 / assessed CVSS 3.1 8.8, CWE-915).
An authentication bypass in Eptura Archibus lets remote attackers execute workflow rules without any credentials by abusing the product's DWR (Direct Web Remoting) endpoint: a request is crafted so that the unauthenticated isPasswordUppercase method is invoked first and a workflow-rule execution method is chained as the subsequent call in the same request. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:L/A:N, 8.6) reflects a network-reachable, unauthenticated, no-interaction attack with high confidentiality impact and limited integrity impact, plus a scope change because the authentication weakness in the DWR layer lets the attacker reach workflow-rule functionality. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis; the primary practical constraint is whether the DWR interface is reachable from the attacker's network position.
OS command injection in television (tv) 0.15.0 through 0.15.9 lets an attacker who can plant a file whose name contains an apostrophe execute arbitrary shell commands with the victim's privileges once that entry is selected and an action is triggered - most notably the bundled default edit action. The vulnerability is local and requires victim interaction (CVSS 4.0 8.5; independently assessed as CVSS 3.1 AV:L/AC:L/PR:N/UI:R with high confidentiality, integrity and availability impact on the victim's account), and no public exploit identified at time of analysis and the issue is not listed in CISA KEV. Upstream fix commits addressing the quoting logic have been published by the vendor.
SQL injection in NocoBase's @nocobase/plugin-collection-sql through 2.2.28 allows an authenticated user with the collection-sql snippet permission to bypass checkSQL() through the sqlCollection:setFields action and persist malicious SQL that executes when the collection reloads. The issue requires high privileges and a PostgreSQL backend for the described impact, where injected statements can read pg_shadow password hashes or invoke pg_read_file; no public exploit was identified at time of analysis. It is a conditional, high-privilege risk rather than an unauthenticated emergency.
Database credential disclosure in Eptura Archibus lets a low-privilege authenticated user retrieve usernames and passwords by submitting a DWR request that names a specific workflow rule; when chained with the companion authentication-bypass flaw, the same primitive enables unauthenticated database reads. The vendor has released a fix referenced by Rapid7, but exploitation requires network reachability to an exposed DWR interface. No public exploit code or confirmed active exploitation has been identified at time of analysis, though the high confidentiality impact and chainability make this a genuine priority for exposed Archibus deployments.
Authenticated stack-based buffer overflow in TP-Link Tapo C320WS V2.0 cameras lets an attacker on the adjacent network who already holds valid device credentials overwrite stack memory through an oversized encrypted password field submitted to the local onboarding Wi-Fi configuration path, ultimately executing commands as root. Because the trigger lives in the provisioning endpoint that is only reachable on the local or onboarding LAN (not from the internet) and requires high-privilege authentication, exploitation is conditionally gated rather than broadly opportunistic; no public exploit code or confirmed active exploitation was identified at time of analysis. Successful abuse lets the attacker take control of the camera, alter its behavior, read sensitive local configuration, and disrupt availability, and TP-Link has published fixed firmware on its download portal.
Local code execution in MobaXterm Personal Edition (Portable) 26.4 GA arises because the application extracts the bundled CygUtils64.plugin without verifying its integrity, allowing an attacker who can write to that file to substitute the contained bin/cygwin1.dll with a malicious library. When the victim subsequently opens a Local Shell session or invokes a Cygwin-based function, the tampered DLL is extracted and loaded in the victim's user context, giving the attacker code execution with the victim's permissions. The flaw requires pre-existing local write access and victim interaction, does not itself elevate privileges, and no public exploit was identified at time of analysis.
BentoML through 1.4.39 renders attacker-controlled docker.env mapping keys into its legacy base.j2 Dockerfile template without neutralizing embedded newline characters, allowing injected Dockerfile instructions - typically RUN commands - to be executed during `bentoml containerize` builds. A victim must be induced to build or containerize an untrusted bentofile.yaml or imported bento archive, so exploitation is local and interaction-dependent (CVSS:3.1/AV:L/AC:L/PR:N/UI:R) rather than remotely triggerable, but successful builds can expose any secrets mounted into the Docker build context and produce poisoned images that downstream users trust and deploy. No public exploit code or confirmed active exploitation was identified at time of analysis; realistic exposure is limited to teams that containerize third-party or otherwise untrusted bento content.
PHP code injection in sqlparse through 0.6.0 can turn crafted SQL text into executable PHP when an application uses the non-default output_format='php' formatter and later runs the generated snippet. The flaw is CWE-94: OutputPHPFilter fails to escape literal dollar signs inside double-quoted PHP strings, so ${expr} or {${expr}} sequences can be interpreted as PHP interpolation. Although the nominal severity is high, exploitation requires a niche formatter plus execution of the generated PHP, and no public exploit was identified at time of analysis.
Missing authorization in the ElementsReady Addons for Elementor WordPress plugin through version 6.7.2 allows any authenticated user at subscriber level or above to overwrite the plugin's stored settings, including saved API credentials and its feature and template configuration. The vulnerable code paths are settings-save handlers that do not halt execution when authorization fails; publicly available exploit code exists, though CISA SSVC rates exploitation as none and the flaw is not in KEV, indicating no confirmed active exploitation. Impact is confined to integrity (CVSS 4.3, PR:L, no confidentiality or availability effect), so it is a moderate, authenticated-access problem rather than an emergency - but on sites with open self-registration, an outside attacker can obtain the required subscriber account and tamper with the plugin's configuration and stored third-party credentials.
Server-side request forgery in the SeleniumScrapingTool of crewai-tools through 1.15.28 lets an attacker who can influence the agent's website_url input - in practice through indirect prompt injection in content the agent processes - steer the local headless Chrome WebDriver to loopback, RFC1918, and link-local cloud-metadata addresses such as 169.254.169.254, disclosing internal service responses and potentially cloud instance credentials. The flaw is unauthenticated from the tool's perspective (CVSS v4.0 AV:N/PR:N, assessed as CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:N/A:N), requires the victim deployment to actually have the tool enabled, and is limited to information disclosure - no integrity or availability impact is assessed. An upstream fix has been proposed in crewAI pull request #6870, but no public exploit code was identified at time of analysis and the issue is not in CISA KEV; it is a credible medium-to-high priority issue rather than an emergency.
LangBot through 4.11.0 accepts Lark/Feishu event-subscription callbacks without verifying the X-Lark-Signature header or verification token, so unauthenticated remote attackers who know a bot UUID can POST forged im.message.receive_v1 and card.action.trigger events into the bot. Successful injection drives the LLM pipeline, tools, and approval workflows as spoofed users, yielding high integrity impact with limited confidentiality exposure while the Lark adapter webhook is network-reachable. No public exploit code or active exploitation has been identified at time of analysis; the AC:H rating reflects the requirement to learn a valid bot UUID and reach the webhook directly.
Idle or half-open connections to aiohttp server deployments at version 3.14.3 and earlier are never timed out during the initial phase of a request, letting a client open a TCP connection and send nothing - or trickle partial header bytes - while holding the socket open indefinitely and consuming server connection capacity. Only deployments that expose the aiohttp listener directly to untrusted clients are affected; the vendor's recommended reverse-proxy pattern with sensible keepalive limits neutralizes the issue, and a meaningful outage requires accumulating many concurrent idle connections because a single stalled connection has negligible impact. There is no public exploit code identified at time of analysis and no confirmed active exploitation (CISA KEV), though the low attack complexity of simply opening sockets makes the flaw cheap to attempt at scale.
Unauthenticated remote attackers can exhaust file descriptors in aiohttp-based web services by sending crafted multipart/form-data requests to any handler that parses bodies with Request.post(), pushing the worker process toward EMFILE and denying service to legitimate clients. The flaw affects aiohttp releases from version 2 up to but not including 3.14.4, and only services that actually accept multipart uploads through that API are exposed; endpoints that never parse multipart bodies, or that use the streaming multipart reader instead, are not exploitable. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but the attack requires no authentication or user interaction and is straightforward to script, so internet-facing upload endpoints should be prioritized for patching.
Pillow versions 10.0.0 through 12.x can free an invalid glyph pointer during FreeType text rendering when an active stroker is used, allowing malformed font bytes supplied by an attacker to corrupt memory or crash the process. Exploitation requires the application to render text with a nonzero stroke width and load an attacker-controlled font from untrusted bytes; no authentication or user interaction is required on the application side, but the attack requirements are present because the stroking path must be enabled. There is no CISA KEV confirmation and no public exploit identified at time of analysis; the issue is fixed in Pillow 13.0.0.
Denial of service in Pillow prior to 13.0.0 occurs when ImageFilter.RankFilter, MedianFilter, MinFilter, or MaxFilter is applied to a zero-width or zero-height image, triggering a native null pointer dereference during edge expansion and crashing the process. Remote, unauthenticated attackers who can supply or cause creation of such a zero-dimension image to an application that uses these rank filters can cause high availability impact only (C:N/I:N/A:H per the assessed CVSS 3.1 vector; official CVSS 4.0 score 8.2 with AT:P). No public exploit code or confirmed active exploitation is identified at time of analysis, and no EPSS data was provided.
Pillow versions 7.2.0 through 12.x can hang indefinitely at full CPU when an application reads n_frames or saves all frames from a crafted MIC image; MicImageFile inherits TIFF frame traversal but its tell() reports the OLE stream index and its seek() resets TIFF frame state, so an embedded TIFF with at least three IFDs never advances the traversal. The attacker only needs to supply the MIC file, but exploitation requires the optional olefile package to be installed and the application to invoke the frame-count or save-all code path - default Pillow installs that never touch MIC frames are unaffected. Impact is confined to availability (CWE-835 uncontrolled loop, no confidentiality or integrity effect); vendor-released patch: 13.0.0.
Heap out-of-bounds read in Pillow's tiled-TIFF decoder (versions 8.2.0 through 12.x) lets a crafted TIFF file cause the stride-and-copy loop in _decodeTile to walk past the buffer libtiff allocated, potentially exposing adjacent heap contents in the returned pixel data or crashing the process. Any application that opens untrusted TIFF images with an affected Pillow build is exposed without authentication or user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:L, 6.5), though impact is bounded to partial confidentiality loss and partial availability loss with no write primitive. No public exploit code and no confirmed active exploitation were identified at time of analysis; the vendor fix in 13.0.0 makes the decoder reject the triggering images with 'decoder error -2'.
Stack exhaustion in the MongoDB PHP driver's BSON decoder allows unauthenticated attackers to terminate PHP processes that process crafted binary documents, causing availability loss. The issue affects driver deployments where application code passes attacker-controlled BSON into the decoder rather than only decoding trusted server responses; no public exploit code has been identified at time of analysis, and the CVSS 4.0 AT:P prerequisite reflects that deployment condition.
The SCIM provisioning endpoints in WSO2 Identity Server, Identity Server as Key Manager, and Open Banking IAM fail to disambiguate between a local user and a federated user that share the same username, so a federated identity can be acted upon as if it were the colliding local account. An attacker who can authenticate as a federated user - and who either already holds a federated identity matching a target's username or can self-register one where self-registration is enabled - can reach the SCIM 2.0 or SCIM 1.1 user endpoints and perform arbitrary operations against the local user store, up to and including account takeover; deployments without self-registration are rated medium severity by the vendor because the collision must be pre-arranged. Exploitation requires authentication as a federated user and a reachable SCIM endpoint, and no public exploit code or confirmed active exploitation was identified at time of analysis; the vendor's own CVSS of 8.2 uses a PR:N vector while our assessment treats the federated-user requirement as PR:L, giving 8.1-equivalent integrity impact with limited confidentiality exposure.
Credential header leakage in follow-redirects 1.16.0 allows remote attackers to receive sensitive headers that should have been stripped when a request follows a cross-origin or HTTPS-to-HTTP redirect to an attacker-controlled target. The flaw only manifests when an application explicitly declares a sensitive header whose name contains the regular-expression metacharacters ^ or |, so conventionally named headers and default configurations are not affected. The vendor fixed the issue in 1.16.1; no public exploit code or confirmed active exploitation was identified at time of analysis.
Cross-request abort in SGLang through 0.5.22 lets unauthenticated remote API clients terminate other users' in-flight generation requests, producing a denial of service against multi-tenant or internet-facing inference servers. An attacker submits a streaming /generate request using a deliberately short, client-controlled rid (for example a single hex character) and then disconnects, at which point the server's prefix-matching abort logic cancels every concurrent request whose identifier begins with that character. The 8.2 CVSS 4.0 score is driven entirely by high availability impact with no confidentiality or integrity effect, and practical impact requires other tenants' requests to be in flight at the same moment; no public exploit code has been identified at time of analysis.
Yank Note releases before 3.93.1 expose a path traversal flaw in the embedded HTTP server's publicly allowlisted /api/help endpoint, letting an unauthenticated remote attacker read arbitrary files - SSH keys, configuration, or stored notes - by supplying repeated '../' segments in the doc or path parameter that slip past the single-replacement sanitizer. Exposure is gated: the server is designed to bind locally, so exploitation requires the instance to be reachable on a non-localhost interface, which is why the assessed vector carries AC:H/AT:P despite PR:N and full confidentiality impact. Impact is disclosure only (no writes, no denial of service); no public exploit code or active exploitation (CISA KEV) was identified at time of analysis, and a vendor fix ships in 3.93.1.
XML external entity injection in the camel-smooks component of Apache Camel (versions 4.7.0 through 4.18.4 and 4.19.0 through 4.22.0) lets remote attackers who can supply or influence an XML message body that is unmarshalled by Smooks read files accessible to the Camel process and force it to issue requests to internal network hosts. No privileges or user interaction are required (CVSS:3.1/AV:N/AC:L/PR:N/UI:N), and no non-default configuration is needed because external entity resolution was the default behaviour of the Woodstox SAX reader Smooks used; the confidentiality impact is high with a low availability impact, giving a base score of 8.2. The flaw is only reachable on routes that unmarshal XML through .unmarshal().smooks(...) or the smooks: component with its default reader, and full return of exfiltrated content depends on an InOut route binding the resolved entity into the reply, so no public exploit code or active exploitation has been identified at time of analysis, though the vendor has released fixed versions.
Unauthenticated remote AS2 partners can turn an Apache Camel camel-as2 receiver into a server-side request forgery pivot: the component reads the asynchronous Message Disposition Notification (MDN) return address out of the inbound message and dials it verbatim, so the sender chooses the host the Camel instance connects to, including addresses only routable from inside the deployment's network. Deployments running Apache Camel 4.0.0 through 4.18.4 or 4.19.0 through 4.22.0 with an exposed camel-as2 receiver are affected; where mdnUserName, mdnPassword or mdnAccessToken are configured, the outbound receipt presents those MDN-delivery credentials to the attacker-chosen destination, which drives the high confidentiality component of the CVSS 3.1 score of 8.2 (CWE-918). No public exploit code has been identified at time of analysis, and vendor fixes are released in 4.23.0, 4.18.5 and 4.22.1; real-world urgency is moderated by whether the receiver is reachable by untrusted partners and whether credentials are attached to MDN delivery.
Authorization bypass in Apache Camel's camel-netty-http component allows remote unauthenticated attackers to reach protected routes by changing the case of characters in the request path so the security constraint no longer recognizes it while routing still dispatches to the endpoint. It affects Apache Camel 4.0.0 before 4.18.5 and 4.19.0 before 4.22.1, with a CVSS score of 8.2; no public exploit identified at time of analysis.
Apache Camel's camel-oauth route guards fail open: when authentication cannot be completed, the OAuthBearerTokenProcessor and OAuthCodeFlow processors set an error status and body but never stop the exchange, so the request falls through and continues into the protected part of the route as if the caller had authenticated. Camel 4.11.0 through 4.18.4 and 4.19.0 through 4.22.0 are affected wherever camel-oauth is used to protect an HTTP-reachable endpoint, and exploitation needs no credentials, user interaction, or special configuration - simply omitting the Authorization header, sending a non-Bearer header, presenting an invalid token, or arriving without an authorization code is enough (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N, 8.2). The gap is a confidentiality problem first and foremost, exposing whatever the protected route returns, with limited integrity impact; no public exploit identified at time of analysis, and the vendor-released patch is 4.23.0, with backports in 4.18.5 and 4.22.1.
Header-driven URI resolution in Apache Camel's HTTP producer components causes message-supplied CamelHttpUri and CamelRestHttpUri values to be expanded through CamelContext.resolvePropertyPlaceholders() before use, so an attacker who can influence those headers turns a URI string into a configuration-evaluation context and can read OS environment variables, JVM system properties, every registered secret-backend PropertiesFunction (AWS, Azure, GCP, HashiCorp, IBM, CyberArk, Kubernetes) and even invoke no-argument methods on beans in the registry. The flaw affects Apache Camel 4.0.0 before 4.18.5 and 4.19.0 before 4.22.1 across camel-http, camel-http-common, camel-vertx-http, camel-undertow and camel-netty-http, and a plain static to(http://backend/api) route is enough to be exposed; no authentication is required where a route is reachable by untrusted senders (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N, 8.2). Exploitation yields a high-confidentiality but limited-integrity impact, and while no public exploit code or CISA KEV entry exists at time of analysis, the preconditions are ordinary and the vendor has shipped fixes, so this warrants prioritised patching.
Heap out-of-bounds write in openGauss Server's HLL (HyperLogLog) unpacking routine lets an authenticated database user corrupt server memory through ordinary SQL. HllObjectUnpack() in src/gausskernel/cbb/utils/hll/hll.cpp trusts an attacker-supplied packed HLL whose encoded lenTotal is smaller than lenUsed, allocates a buffer sized to lenTotal but then copies lenUsed bytes using memcpy_s() with the wrong destination size, so the safe-copy guard never fires. Any non-privileged user with a valid connection can reach the path via hll_in(), hll_print(), or hll_cardinality() - for example by casting bytes with ::hll - affecting versions from 2.1.0 through 7.0.0-RC3 (fixed in 7.0.0-LTS); the CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H reflects high integrity and availability impact, and no public exploit was identified at time of analysis.
An uncontrolled search path element in Dell Application Store (CWE-427) lets a local, low-privileged user plant a malicious library or executable in a location the installer or updater searches, so the higher-privileged Application Store process loads attacker code and yields elevation of privilege plus arbitrary code execution. All builds prior to 26.05.0.7 are affected; the CVSS 3.1 vector is AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8), meaning the attacker must already hold a local account or code-execution primitive on the host, no victim interaction is required, and impact is confined to that machine. There is no remote attack surface here - it is a post-compromise or insider escalation step rather than an entry vector - and no public exploit code has been identified at time of analysis, with no CISA KEV listing.
Header injection in the Subscribe to Comments WordPress plugin before 2.3.3 allows authenticated users with Author-level access or higher to insert CR/LF characters into the notification sender-name setting, appending arbitrary e-mail headers such as a hidden Bcc and spoofing the From address on outbound notifications. Publicly available exploit code exists, but CISA KEV does not list this issue. Impact is confined to notification e-mail rather than code execution on the WordPress host, and sites without untrusted Author-or-higher accounts are effectively not exposed.
Use-after-free in GIMP's XCF loader can crash the application and potentially allow arbitrary code execution when a user opens a crafted .xcf file that selects a path and then fails to load it. The flaw affects GIMP as packaged in Red Hat Enterprise Linux 6 through 10 according to the provided CPE mappings, and exploitation is local and requires user interaction (CVSS 7.8, AV:L/UI:R/PR:N); no public exploit was identified at time of analysis. Because scope is unchanged, any code execution would run with the privileges of the user opening the file rather than automatically gaining root.
Opening a crafted XCF file in GIMP can trigger a use-after-free in the XCF loader's linked-channels handling, crashing the main GIMP process and potentially enabling code execution in the opening user's context. The defect affects GIMP installations that parse XCF files, with Red Hat tracking impact across RHEL 6 through RHEL 10 packages; exploitation requires local delivery and a victim to open the malicious image, and no public exploit code or CISA KEV entry is identified in the provided data.
Heap out-of-bounds read and write in GIMP's PSD thumbnail resource loader allows memory corruption when a victim opens or thumbnail-previews a crafted PSD file containing a grayscale JPEG thumbnail, potentially leading to code execution in the plug-in process. The loader assumes a 3-byte BGR stride and never validates that the embedded thumbnail is RGB, so a single-channel grayscale image drives out-of-bounds indexing. Rated CVSS 7.8 (AV:L/UI:R/PR:N) - a client-side file-parsing bug with no network reachability; no public exploit code identified at time of analysis, and Red Hat tracks it across RHEL 6 through 10.
Local privilege escalation in Progressive Robot hMailServer 6.0.0 through 6.3.6 allows any authenticated, non-administrator user on the host to run code as LocalSystem or as the mail server's virtual service account, but only when the installer was pointed at a folder that inherits writable permissions from its parent, such as the root of an NTFS drive. The installer accepts any path without warning and creates neither the program folder nor its Bin subfolder with explicit permissions, so a drive-root install leaves Bin writable to Authenticated Users (Modify on Windows clients) or Users (create files and folders on Windows Server); the default Program Files installation grants ordinary users only read and execute and is explicitly not affected. No public exploit code or active exploitation is confirmed at time of analysis, and the reference to the v6.3.7 release indicates the vendor has shipped a fixed version.
Path traversal in Koozali SME Server 11.0rc1-215 allows remote unauthenticated attackers to read files outside the intended logs directory through the server-manager View Logs feature, exposing system and application files with high confidentiality impact but no integrity or availability effect. The CVSS 4.0 vector rates exploitation maturity as E:P, so publicly available exploit code exists at the proof-of-concept level, but there is no CISA KEV confirmation of active exploitation. Real-world exposure is bounded to instances whose administrative web interface is reachable from untrusted networks.
Arbitrary Python code execution in docTR through 1.1.0 is possible when load_pretrained_params() deserializes an attacker-controlled or tamperable checkpoint on PyTorch releases before 2.6. Unauthenticated attackers can supply the poisoned model artifact, but exploitation is conditionally gated: the victim application must load that checkpoint from a path or URL the attacker controls, and PyTorch must predate 2.6, where torch.load began defaulting to weights_only=True. No public exploit code or CISA KEV entry was identified at time of analysis, and this is a genuine but conditionally-gated code-execution flaw rather than a drop-everything emergency.
Business-logic validation in Salon Booking System before 10.31.11 lets an unauthenticated visitor who holds a valid fixed-amount discount code submit a confirmed booking with a negative total. The issue is low severity (CVSS 3.7, AC:H) because exploitation depends on a currently valid code whose value exceeds the booking subtotal; publicly available exploit code exists, and the supplied data contains no CISA KEV confirmation. Sites that do not issue fixed-amount discount codes are not realistically exposed.
Path traversal in the MapSVG Lite WordPress plugin through version 8.16.1 allows an authenticated low-privilege user to supply directory traversal sequences to a file-handling parameter and delete files outside the plugin's intended directory, causing high availability impact. Because the CVSS vector is PR:L with UI:N, any account at the low privilege tier is sufficient, and sites that allow untrusted user registration are most exposed. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis.
Heap use-after-free in Pillow 11.3.0 through 12.x can crash any Python process that encodes TIFF data into an in-memory buffer while an attacker influences the TIFF tags being written. When an application saves to BytesIO with a tiffinfo dictionary containing a tag libtiff rejects during encoding - the documented trigger is a floating-point predictor (PREDICTOR=3) applied to integer sample data - TIFFWriteScanline fails inside ImagingLibTiffEncode, the error path frees the output buffer without closing the TIFF handle, and a later cleanup flushes buffered bytes through the write callback into freed memory. The vector (CVSS 5.9, AV:N/AC:H/PR:N/UI:N, C:N/I:N/A:H) reflects unauthenticated but configuration-dependent reachability: exploitation needs the memory-buffer code path plus attacker-controlled tag values, and the reliable outcome is process termination, with code execution unproven; no public exploit identified at time of analysis, and the upstream fix commit ships a regression test rather than weaponized tooling.
Denial of service in FFmpeg build N-119856-gbe46370941 occurs when the H.264 decoding path processes a crafted media file and dereferences a NULL pointer in avpriv_h264_has_num_reorder_frames, crashing the affected process. The CVSS 3.1 score is 7.5 with availability-only impact (C:N/I:N/A:H) and an AV:N/AC:L/PR:N/UI:N vector, making it remotely reachable without privileges or user interaction in automated decoding pipelines; services that automatically ingest untrusted media are the highest-risk exposure, while manual-open scenarios add user interaction not reflected in the vector. No public exploit identified at time of analysis, and CISA SSVC records exploitation as none with automatable set to yes.
Denial of service in hMailServer 6.0.0 through 6.3.6 lets a remote unauthenticated sender exhaust the mail queue and disk and stop the server from carrying mail at all. The server trusts a client-supplied X-hMailServer-LoopCount header, reading it with a signed conversion and no validation, so a negative value - or, on Linux builds, a value above the 32-bit signed maximum that wraps negative - passes every check against the default loop limit of 5 and lets a message caught in a forward, redirect, or auto-reply cycle iterate roughly two billion times, each hop queuing and delivering another message. Exploitation is conditional: the targeted account or domain must have a mail-generating feature that can form a cycle (rule forward/reply/copy, account forward, Sieve redirect/vacation/notify, bounce, or out-of-office reply); no public exploit code was identified at time of analysis and there is no CISA KEV listing, and the CVSS 3.1 score of 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) reflects pure availability impact with no confidentiality or integrity loss.
GeoVision GV-ASmanager's GeoWebServer.exe web service is vulnerable to a stack-based buffer overflow that allows remote, unauthenticated attackers to crash the service, causing a denial-of-service condition. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) confirms only an availability impact; confidentiality and integrity are unaffected. No public exploit code or active exploitation has been identified at time of analysis, but any exposed GV-ASmanager web port could be disrupted.
DKIM signing in Progressive Robot hMailServer 6.0.0 through 6.3.6 can be induced to sign attacker-authored mail with the DKIM key of any hosted domain named in the message's From header, because signing happens on the first delivery pass before local delivery and without checking the sender's authenticated identity. A remote unauthenticated sender can therefore obtain a valid, DMARC-aligned signature for a hosted domain, but only where an administrator has enabled DKIM signing for that domain and an external relay path such as a forward, alias, list, Sieve redirect, mirror or quarantine release carries the message off-server; a separate authenticated-SMTP variant lets a logged-in account get mail signed for a different hosted domain when SmtpAuthenticatedSenderCheck is disabled. Rated CVSS 7.5 with integrity impact only; no public exploit identified at time of analysis.
Algorithmic complexity (quadratic-time) denial of service in markdown-it's smartquotes typographic rule affects releases prior to 14.3.2 and 15.0.2 when the parser is configured with typographer: true. Unauthenticated remote attackers who can submit Markdown for rendering - for example in comment fields, chat messages, or wiki pages - can supply a document containing many opening double quotes followed by unmatched closing single quotes (or the same pattern with quote types reversed), forcing the smartquotes matching loop to rescan the entire opener stack on every quote and driving CPU consumption up quadratically with input size. The default typographer: false configuration is unaffected, and the impact is limited to availability (CVSS 3.1: AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5); no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV), though the advisory notes the vulnerable option is enabled with high probability in real deployments.
IBM Concert versions 1.0 through 3.0.0 rely on weaker-than-expected cryptographic algorithms when protecting sensitive data, allowing an attacker who obtains that ciphertext - captured network traffic or exfiltrated at-rest data - to decrypt highly sensitive information. The weakness is confidentiality-only (C:H/I:N/A:N) with no authentication or user interaction required per the CVSS vector, though practical exploitation demands prior possession of the encrypted material and non-trivial cryptanalytic effort, which is why the independently assessed vector rates complexity as High rather than Low. No public exploit code or confirmed active exploitation was identified at time of analysis, and IBM has released a vendor patch.