Heap-based buffer overflow in libaribb24 1.0.3 and earlier allows crafted ARIB STD-B24 caption PES packets processed through arib_parse_pes() to overflow a heap buffer, crashing FFmpeg, VLC, or other linked consumers and potentially corrupting adjacent memory. Exploitation is file- or stream-driven and requires the victim to open a malicious media file or process a crafted broadcast stream, and it only affects applications that actually invoke ARIB caption decoding. No CISA KEV listing or public exploit code was identified at time of analysis.
Heap out-of-bounds read in Netpbm's rasttopnm converter through 11.16.00 can expose up to 255 adjacent heap bytes in generated PNM output, or crash the conversion, when a crafted colormapped Sun rasterfile contains pixel index bytes beyond the supplied palette length. The issue requires a user or automated workflow to feed the malicious rasterfile to rasttopnm, is locally oriented, and does not provide code execution or memory writes. No public exploit or CISA KEV confirmation is available at time of analysis, and the CVSS 4.0 vector indicates no privileges required but user interaction.
Heap-based out-of-bounds write in Netpbm's rasttopnm Sun rasterfile decoder (pr_load_image) allows an unauthenticated local attacker to corrupt memory by supplying a crafted byte-encoded .ras file that declares tiny dimensions but carries an oversized run-length payload. The flaw affects Netpbm through 11.16.00 and is triggered when the victim or an automated pipeline runs rasttopnm on the malicious Sun rasterfile, causing memory corruption, crashes, and possible low-integrity effects. No public exploit code was identified at time of analysis, and the independent assessment rates this as Medium (CVSS 3.1 6.9) because exploitation is local and requires user interaction.
Server-side request forgery in SGLang through 0.5.22, when deployed in prefill/decode disaggregation mode, allows unauthenticated remote attackers to force the Decode worker to make outbound connections to attacker-chosen internal hosts and ports via the client-supplied bootstrap_host and bootstrap_port fields on the /generate endpoint. This enables blind internal network probing and can block the shared scheduler loop, delaying other inference requests. The CVSS 4.0 score is 6.9 (AV:N/AC:L/AT:N/PR:N/UI:N), reflecting network-reachable, low-complexity, unauthenticated exploitation with limited confidentiality and availability impact; no public exploit code or active exploitation has been identified at time of analysis.
Path traversal in Mopidy before 4.0.5 lets unauthenticated clients use JSON-RPC or WebSocket calls such as core.library.lookup and core.tracklist.add with file:// URIs to reach files outside the configured file/media_dirs, enabling file-existence probing, tag metadata disclosure, and playback of out-of-sandbox files. The impact is limited to those operations rather than arbitrary full-content file reads or code execution, and exploitation requires the file backend extension to be enabled plus the HTTP frontend's JSON-RPC/WebSocket API to be reachable; because Mopidy's HTTP server binds to 127.0.0.1 by default, remote exposure generally requires an operator to have reconfigured it for non-loopback access. No public exploit code has been identified at time of analysis, and the issue is assessed as medium severity.
A race condition in IBM Storage TS4500 Library firmware versions 1.1.1.6 through 1.12.0.3 lets a remote, low-privileged authenticated user escalate to administrative privileges by timing an operation against a concurrent privileged action. The flaw is a privilege-escalation issue rather than a pre-authentication bypass, since valid credentials for the library management interface are mandatory, and successful exploitation depends on winning a non-deterministic race that may require repeated attempts. IBM has released a fix; no public exploit code or confirmed active exploitation was identified at time of analysis, and the EPSS-style risk profile places this as a patch-on-a-normal-cycle item.
An uncontrolled memory allocation in VideoLAN libbluray through 1.5.1 lets a crafted Blu-ray clip-information (.clpi) file drive memory and CPU exhaustion, crashing or hanging any application linked against the library that opens the media. The flaw sits in _parse_extent_start_points() in clpi_parse.c, which allocates based on the attacker-controlled num_point field without validating it against the actual file size. Exploitation is local and requires the victim to load the malicious disc, image, or directory (CVSS:3.1/AV:L/AC:L/PR:N/UI:R, availability-only), so impact is confined to denial of service with no data exposure or code execution; no public exploit code was identified at time of analysis, though a public technical writeup describing the parsing flaw exists.
Out-of-bounds read in VideoLAN libbluray through 1.5.1 can crash applications that embed the library when a crafted ClipInfo (.clpi) file containing an empty EP-map fine table is opened and a seek operation accesses that table, resulting in denial of service. The attack is local and requires user interaction to open attacker-supplied Blu-ray content; impact is limited to availability, with no code execution or data disclosure. No public exploit was identified at time of analysis, and the issue is rated medium severity.
Heap out-of-bounds read in libdisplay-info 0.4.0's DisplayID v2 parser lets a crafted EDID over-advance the parse cursor and crash the consuming application. The vulnerable path is reachable when an application parses attacker-controlled EDID data supplied through a malicious monitor, KVM, capture device, or crafted file, requiring local access and passive user interaction. This is a medium-severity denial-of-service issue, not a critical priority, with no code execution or confidentiality impact and no public exploit identified at time of analysis.
Heap out-of-bounds read in libdisplay-info through 0.4.0 lets a crafted EDID trigger a crash in applications that parse it. The bug is in the DisplayID v1 section parser in displayid.c, where a data block's declared length can exceed the section and drive is_all_zeroes past the heap buffer; delivery is local/physical via a malicious monitor, KVM, capture device, or crafted EDID file and requires passive user interaction. Impact is limited to denial of service (availability only), and no public exploit was identified at time of analysis.
Crafted messages published into IBM MQ 9.4.5.0 or 9.4.5.1 can crash the applications that consume them, giving an authenticated message producer a denial-of-service primitive against queue-processing services. Successful exploitation requires a valid MQ identity with put authority on a queue that a vulnerable consumer reads; the CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, score 6.5) confirms the attacker must be authenticated and that only availability is impacted, with no confidentiality or integrity effect. There is no CISA KEV listing and no public exploit identified at time of analysis, so this should be handled as routine, medium-severity patch management rather than emergency response, especially since deployments outside the 9.4.5.0-9.4.5.1 range are not affected.
Access-control bypass in openGauss Server's HADR/SW streaming-replication authentication lets remote, unauthenticated attackers satisfy HBA checks and read backup and log data over the replication protocol. The flaw affects 3.0.x, 3.1.x, 5.0.x, 5.1.0, 6.0.x and 7.0.0-RC1 through RC3, but is only reachable when a permissive replication pg_hba.conf entry (notably 'trust') matches connections originating outside the internal node network, so real-world exposure is configuration-dependent and the assessed base score is 6.5 (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N - confidentiality only). It is fixed in 7.0.0-LTS; no public exploit code has been identified at time of analysis.
Authenticated denial of service in IBM MQ container deployments - specifically the MQ Operator and MQ Advanced container images - lets a remote user who already holds valid MQ credentials crash the queue manager by sending specially crafted multicast status messages that drive the process into a NULL pointer dereference. Impact is availability-only (CVSS 6.5, A:H with C:N/I:N); confidentiality and integrity are unaffected. Exploitation is further constrained because the target deployment must have multicast messaging configured and enabled, a non-default capability absent from most standard queue-manager installations, and no public exploit has been identified at time of analysis.
Denial of service in IBM MQ Operator and MQ Advanced Container Images allows an authenticated MQ client to crash the queue manager agent by sending a crafted asynchronous consume request that triggers untrusted deserialization (CWE-502). The CVSS 6.5 vector confirms network reachability, low privileges (PR:L), no user interaction, and availability-only impact; confidentiality and integrity are unaffected, and this is a moderate-priority availability issue rather than a top-tier emergency. No public exploit was identified at time of analysis, CISA SSVC rates exploitation as none and automatable as no, and IBM has published a vendor patch.
hMailServer 6.2.22 through 6.3.6 contains a missing-authorization flaw that lets any authenticated account make the server emit mail with an arbitrary From address through the Sieve notify action, and 6.0.0 through 6.3.6 exposes the same issue through the mail-rule Reply action. The forged message can be DKIM-signed with the key of any domain the server hosts when the claimed sender belongs to that domain, so it can align with and pass that domain's DMARC policy; no public exploit was identified at time of analysis, and exploitation requires valid credentials plus the ability to store a Sieve script or act on mail rules.
Denial of service in IBM Storage TS4500 Library and IBM Diamondback Tape Library firmware versions 1.1.1.6 through 1.12.0.3 allows an authenticated low-privilege user to exhaust system resources by sending specially crafted SMTP requests to the library's email/notification management interface. The issue is a moderate, not top-tier, priority because authentication is mandatory, impact is limited to availability, and the appliance is typically internal rather than internet-exposed; no public exploit was identified at time of analysis. A vendor patch is available per IBM advisory node/7292612.
Denial of service in IBM MQ Operator and IBM MQ Advanced container images lets an authenticated MQ client crash the queue manager by sending an MQOPEN request whose offset values are not properly validated, producing a buffer-handling fault in the queue manager process. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) shows the limiting factor is credentials: the attacker must already hold a valid MQ identity and an established connection able to issue MQ API calls, so exposure is limited to insiders or attackers who have compromised an MQ application identity. Confidentiality and integrity are unaffected, the vendor has published a fix, and no public exploit code or active exploitation has been identified at time of analysis (CISA SSVC exploitation: none, automatable: no).
Authenticated users of IBM MQ Operator and IBM MQ Advanced container image deployments can cause a denial of service against the queue manager by submitting malformed RFH2 message header fields through queued publish/subscribe operations. The flaw is rated CVSS 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H), reflecting high availability impact only - there is no disclosure or modification of message data - and requires valid MQ credentials with authorization to publish or subscribe, so anonymous remote parties are not positioned to exploit it. No public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor has published remediation guidance; the practical exposure is limited to environments that both grant the attacker a usable principal and expose queued pub/sub messaging.
IBM MQ Operator and MQ Advanced container images can be driven into a denial-of-service condition by an authenticated queue-manager user who submits a specially crafted message that forces excessive memory operations during character-set (CCSID) conversion; the CVSS 3.1 score is 5.3 with an all-availability impact, high attack complexity, and low privileges required. No public exploit code or confirmed active exploitation was identified at time of analysis, and EPSS data was not provided, so this is a moderate-severity, low-priority issue rather than an urgent threat. Impact is confined to service disruption - there is no confidentiality or integrity exposure from the conversion fault itself.
Authenticated hMailServer users (6.0.0 through 6.3.6) can rewrite identity headers - From, Sender, Resent-From, Resent-Sender and DKIM-Signature - on mail the server itself sends, because the Sieve editheader action (introduced in 6.2.22) and the mail-rule 'Set header value' action apply header edits before a redirect, forward or copy is queued without any authorization check on those fields. The impact is email forgery: when the impersonated address sits at a domain the server hosts and signs for with DKIM and the message carries no existing signature of that domain, hMailServer signs the forged message on its first delivery pass and the result can align and pass the domain's DMARC policy; where that DKIM condition is not met the attacker can still spoof the From address but without a valid signature. Exploitation requires a valid authenticated principal (CVSS PR:L - a Sieve-capable mailbox, a domain administrator, an account scripting its own rules over COM, or a domain-scoped REST API key from 6.3.4), no public exploit code was identified at time of analysis, there is no CISA KEV entry, and vendor release 6.3.7 addresses the flaw.
WSO2 Carbon OAuth, as shipped in WSO2 Identity Server, API Manager, and related WSO2 products, can leave session-bound tokens valid after the user session ends when token binding validation is enabled and the 'Revoke token upon user logout' option is inactive. An attacker who already possesses such a token can retain access to protected applications and data after logout; this is a moderate, conditionally exploitable session-management flaw that requires a non-default configuration and prior token acquisition, and no public exploit code or active exploitation is identified at time of analysis.
Local file inclusion in the WordPress plugin WP Mailster through version 1.9.1.0 lets an authenticated user who can reach a vulnerable plugin endpoint steer a PHP include/require path toward files on the host, disclosing their contents to the attacker. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, score 6.5) means a valid WordPress session is required and the outcome is confidential-data exposure rather than code execution, data tampering, or denial of service. There is no CISA KEV listing and no public exploit code identified at time of analysis, so this is a moderate-priority patch-promptly item rather than an emergency; the practical risk scales with how low-privileged a role can reach the affected feature, which should be confirmed against the Patchstack advisory.
Stored cross-site scripting in Crocoblock JetElements For Elementor through version 2.9.2.4 allows an authenticated WordPress user with low-level content privileges to inject a script into a JetElements widget; the payload executes when another user, such as an administrator, views or edits the affected page. The issue is rated CVSS 6.5 and requires victim interaction, so exploitation is constrained by content-authoring permissions and user behavior. No public exploit code or active exploitation was identified at time of analysis.
Stored cross-site scripting in the E2Pdf WordPress plugin through 1.32.57 allows a low-privileged authenticated user to persist malicious input that executes when a higher-privileged victim views the affected page or stored content, potentially within the victim's browser session. The CVSS 3.1 score is 6.5 with a scope change (AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N), reflecting the need for an authenticated account and victim interaction; no public exploit code or CISA KEV entry was identified at time of analysis, making this a moderate rather than critical priority.
Denial of service in the GStreamer ASF demuxer (gst-plugins-ugly), rated CVSS 6.5, allows a crafted ASF, WMV, or WMA file to drive an oversized heap allocation because an attacker-controlled Simple Index entry count is not bounded by the object's actual payload. The issue affects gst-plugins-ugly packages in Red Hat Enterprise Linux 7, 8, 9, and 10; exploitation requires a victim to open or preview the malicious media file, with an unauthenticated network vector and user interaction required, and impact is limited to availability loss with no code execution or data exposure. No public exploit identified at time of analysis.
Stored cross-site scripting in YITH WooCommerce Wishlist through 4.18.1 lets authenticated low-privileged users persist crafted input that executes in another user's browser when poisoned wishlist content is viewed. The plugin must be active alongside WooCommerce, and the attacker needs an account on the WordPress site, so exploitation depends on a victim, potentially an administrator, interacting with the stored payload. No public exploit identified at time of analysis; CVSS 6.5 reflects partial confidentiality, integrity, and availability impact with scope change.
External entity expansion (XXE) in Apache Camel's camel-fop component lets an unauthenticated remote sender who can deliver an XSL-FO body to a fop producer read files accessible to the Camel process and force that process to make outbound requests to attacker-named hosts. The flaw is conditional: FopProducer relies on TransformerFactory.newInstance() plus FEATURE_SECURE_PROCESSING, which is sufficient only for the JDK's built-in transformer, so exploitation requires a third-party JAXP factory such as Saxon-HE (typically pulled in via camel-xslt-saxon or camel-saxon) on the classpath - default camel-fop deployments are not affected. There is no public exploit code or CISA KEV entry identified at time of analysis, and the CVSS 6.5 score reflects high attack complexity and confidentiality-heavy impact (C:H/I:L) rather than easy mass exploitation; fixes are shipping via upstream PRs, but 4.14.x and earlier releases are end-of-life and will never receive one.
Unfiltered MIME headers in Apache Camel's camel-mail component (4.0.0 through 4.18.4 and 4.19.0 through 4.22.0) allow an external message sender to place mail.smtp.* / mail.smtps.* names onto the Camel Exchange when a multipart message is unmarshalled with the MimeMultipart data format and inline headers enabled. Because those names fall outside the Camel* namespace that consumer-side header filters block, they can steer how a downstream mail producer connects and sends, yielding low confidentiality and integrity impact (CVSS 6.5, network-reachable and unauthenticated per the CVSS:3.1/AV:N/AC:L/PR:N/UI:N vector). This is an incomplete fix of CVE-2026-46584 rather than a new defect class, so deployments that applied that earlier advisory and considered camel-mail settled remain exposed on this path; no public exploit code was identified at time of analysis and the vulnerable topology is a specific, non-default route configuration.
Cross-partner signing-key confusion in the Apache Camel AS2 component (4.0.0 through 4.18.4 and 4.19.0 through 4.22.0) can cause a Message Disposition Notification to be signed with another trading partner's key when a multi-partner server handles concurrent or successive requests using dynamically fetched per-request keys. The issue is remotely reachable without authentication per the CVSS vector but has high attack complexity because exploitation depends on overlapping partner traffic through a shared ResponseMDN instance; it can expose signing material and misattribute receipts, with practical exposure limited to deployments serving multiple partners from one Camel context. No public exploit identified at time of analysis, and no KEV confirmation was provided in the supplied data.
Reflecting caller-chosen request headers back into responses is possible in Apache Camel's platform-http component (4.0.0 before 4.18.5, and 4.19.0 before 4.22.1) because the guard that suppresses sensitive headers compares names case-sensitively, so a caller can defeat it by changing header casing - and on HTTP/2, where field names must be lowercase on the wire, the suppression never fires at all. Unauthenticated remote attackers (CVSS:3.1/AV:N/AC:L/PR:N/UI:N, 6.5) can therefore have content they control echoed into the response, which is the primitive behind response-splitting and cache-poisoning attacks against proxies or caches sitting in front of the Camel endpoint. Vendor patches are available in 4.23.0, 4.18.5 and 4.22.1; no public exploit code and no confirmed active exploitation were identified at time of analysis, and practical impact is gated by whether a fronting cache or proxy acts on the reflected content.
Header injection in the Apache Camel Tika producer (tika:parse) lets a crafted document write arbitrary names into the Camel Exchange header namespace, because every metadata key parsed out of the submitted file is mapped onto the message with no filter. Routes running Camel 4.0.0 through 4.18.4 and 4.19.0 through 4.22.0 that parse untrusted files and then hand the message to a component that acts on Camel-namespace headers - most notably CamelFileName, which file endpoints use to decide the write path - can be steered by an attacker-chosen metadata name such as an HTML <meta name="CamelFileName" content="../../pwned"/>. Unauthenticated remote attackers can supply the document (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N as independently assessed; the vendor published 6.5 with AC:L, while the higher attack complexity reflects the non-universal route configuration required); no public exploit code or CISA KEV entry was identified at time of analysis, and vendor-released patches exist in 4.23.0, 4.18.5 and 4.22.1.
Credentialed cross-origin data exposure in Apache Camel's platform-http-vertx component (4.0.0 through 4.18.4, and 4.19.0 through 4.22.0) lets a malicious page read authenticated responses from a Camel HTTP endpoint. The CORS handler sets Access-Control-Allow-Credentials: true outside its origin check, and when camel.server.cors.origins is left unset it reflects the caller's own Origin back - the combination browsers permit for credentialed requests even though a literal wildcard is forbidden. Rated CVSS 6.5 (AV:N/AC:L/PR:N/UI:R/C:H/I:N/A:N) because a victim with an active session must be lured to an attacker-controlled page; no public exploit code or confirmed active exploitation was identified at time of analysis, and an explicit origin allow-list fully prevents it.
Stored cross-site scripting in Themeum Tutor LMS through 4.1.2 lets an authenticated low-privilege user, such as an instructor or student able to submit stored content, persist script that executes when another user views the affected page. The plugin does not properly neutralize input during web page generation (CWE-79), and exploitation also requires victim interaction, so sites with open registration or broad Tutor LMS role assignment face greater exposure. The issue is rated CVSS 6.5, and no public exploit was identified at time of analysis.
Netskope Client (NSClient) versions prior to R142 can retain an open captive-portal session after a device moves from an attacker-operated access point presenting a captive portal to another network that already has internet access. The stale portal context can then be abused by a rogue access point to direct users to malicious sites or facilitate data exfiltration. Exploitation requires adjacent Wi-Fi control and victim interaction (connecting to the rogue AP and later roaming); no public exploit code has been identified at time of analysis, and the issue is rated CVSS 6.4.
Traefik's Kubernetes Ingress provider omits namespace validation for annotations that reference Middleware, ServersTransport, and TLSOptions resources, so a tenant with RBAC rights to create or update Ingress or Service objects in one namespace can point router.middlewares or service.serverstransport at another tenant's objects. In multi-tenant clusters that depend on namespace separation, this can expose another tenant's injected credentials or allow reuse of its client certificates, undermining tenant isolation; single-tenant deployments are not meaningfully affected. This is an authorization/tenant-isolation flaw (CWE-862) rather than anonymous network exploitation, and no public exploit code was identified at time of analysis.
Privilege escalation in Essential Addons for Elementor through 6.8.5 allows a high-privilege authenticated WordPress user to gain greater capabilities when required user interaction occurs and additional attack conditions are satisfied. The flaw is a CWE-266 incorrect privilege assignment issue rated CVSS 6.4, reported by Patchstack; exploitation is constrained by PR:H, UI:R, and AC:H, so it is not remotely reachable by an unauthenticated attacker and reliable opportunistic exploitation is difficult. No public exploit identified at time of analysis, and no CISA KEV active-exploitation status was provided.
Server-side request forgery in the MISP Modules html_to_markdown expansion module lets an authenticated user who can create or modify MISP attributes force the MISP server to fetch URLs pointing at internal address ranges the module's is_safe_url() denylist failed to cover. The gaps include 0.0.0.0/8 (which routes to loopback on Linux), 100.64.0.0/10 carrier-grade NAT space, and the IPv6 unspecified (::/128), unique-local (fc00::/7) and link-local (fe80::/10) ranges, with IPv4-mapped IPv6 forms such as [::ffff:0.0.0.0] also slipping through. Successful abuse gives read access to internal services reachable from the MISP host but does not compromise MISP itself; no public exploit code or CISA KEV entry was identified at time of analysis, and the vendor has published a fix commit.
HTTP request smuggling in aiohttp's pure-Python HTTP parser (versions prior to 3.14.4) can let an unauthenticated remote attacker desynchronize request framing between aiohttp and a front-end proxy when the application runs without the standard compiled llhttp extension - for example with AIOHTTP_NO_EXTENSIONS set or when no compatible wheel is installed. Exploitation additionally requires an intermediary that interprets ambiguous HEAD-with-Content-Length framing differently from the backend, so default installations using the C extension are not vulnerable; no public exploit was identified at the time of analysis, and this is a medium-severity, conditionally exploitable flaw rather than a broadly exploitable one.
Out-of-bounds heap read in Pillow prior to 13.0.0 lets unauthenticated remote attackers disclose up to three adjacent heap bytes or crash the process, but only when the application explicitly decodes attacker-controlled data using the uncommon planar palette raw modes P;2L or P;4L. This is a genuine but moderate-severity CWE-126 memory-safety defect rather than a top-tier priority: these raw modes are not reached by ordinary image-file opening or auto-detection, and impact is bounded to limited information disclosure or denial of service with no code execution or integrity loss. No public exploit identified at time of analysis; the provided intelligence contains no KEV listing and no POC reference.
Unbounded recursion in Pillow's PDF parser (versions 5.1.0 through 12.x) can crash a Python worker when an application opens an attacker-supplied PDF for append, producing availability-only denial of service. The issue is reachable only when the application explicitly uses Pillow's PDF append mode on untrusted input; the independent assessment rates it as a modest-priority availability issue, not a top-tier emergency, and no public exploit has been identified at time of analysis. Pillow 13.0.0 fixes the problem by capping parser nesting depth.
radare2 6.2.0 and 6.2.2 fail to actually enforce confinement on commands submitted to its built-in HTTP server: when http.sandbox=true, requests to the /cmd endpoint are supposed to run under a restricted sandbox, but because cfg.sandbox.grain defaults to 'all', process-execution and other capabilities are never revoked, so a remote unauthenticated party who can reach the server can bypass the protection mechanism and spawn processes on the analyst's host. Exploitation is rated high complexity and non-default - the operator must have explicitly started the HTTP server (=h or background =h&) and exposed it to an untrusted network, and http.auth is disabled by default - so overall real-world risk is low despite a high-context CVSS assessment (C:H/I:H/A:H vs. the CNA's more conservative 6.3). No public exploit code or active exploitation was identified at time of analysis, and the vendor shipped a fix in 6.2.4.
AIOHTTP versions up to and including 3.14.3 fail to honor the Secure attribute on 'shared' cookies (cookies set without a Domain attribute) inside CookieJar.filter_cookies(), so a Secure-marked shared cookie can be attached to a plain http:// request. Unauthenticated remote attackers in an on-path/man-in-the-middle position can passively read that cookie value from the cleartext traffic, resulting in limited confidentiality disclosure with no integrity or availability impact. Exploitation requires the application to actually issue an unencrypted request to the cookie's host; domain-scoped Secure cookies are unaffected, and no public exploit code has been identified at time of analysis. The flaw is fixed in aiohttp 3.14.4.
IBM TS4500 Library firmware 1.1.1.6 through 1.12.0.3 fails to invalidate sessions, allowing an authenticated attacker who retains a usable session identifier to impersonate another user on the library management interface. CVSS 3.1 scores this 6.3 with vector AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L, meaning exploitation requires an authenticated session and is bounded to limited confidentiality, integrity, and availability impact. No public exploit identified at time of analysis, and IBM has published a vendor patch advisory.
aiohttp web servers running versions prior to 3.14.4 derive the value of Request.scheme from the request line when a client sends an absolute-form request-target (for example 'GET https://host/path HTTP/1.1'), so an unauthenticated remote attacker can make an unencrypted HTTP connection appear to the application as HTTPS, or an encrypted connection appear as plaintext. Applications that branch on Request.scheme for security decisions - setting the Secure flag on cookies, forcing HTTPS redirects, or gating trust decisions - can therefore be induced to make the wrong call, yielding low confidentiality and integrity impact (our independent CVSS 3.1 assessment: AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N). Exploitability is materially narrowed by an attack requirement (CVSS 4.0 AT:P): the target application must actually consume Request.scheme for a security decision, and no public exploit code has been identified at time of analysis; the issue is fixed in aiohttp 3.14.4.
Out-of-bounds read in libtins through 4.6 can crash applications that parse attacker-supplied DNS SOA records through the library's buffer constructor and may expose limited adjacent heap data. The flaw occurs in DNS::soa_record::init when SOA RDATA lacks a NUL terminator, causing strlen to run past the heap buffer; remote unauthenticated attackers can trigger it only against applications that actually feed untrusted SOA data into this constructor. No public exploit or CISA KEV entry was identified at time of analysis, and the assessed CVSS 3.1 score is 6.3 with high attack complexity due to heap-layout and NUL-byte preconditions.
Improper TLS certificate validation in TikTok Video Downloader PHP allows unauthenticated remote attackers who already hold a man-in-the-middle position to supply forged HTTPS certificates to index.php cURL requests, compromising the integrity of data fetched from TikTok APIs and CDN endpoints. The issue affects rolling-release revisions up to commit c4230497bb23dd9c1f81456fe8a982d951feac0d and is fixed by commit 64c0155abb88e714198241d41b918cefc0d5a42a; exploitation requires a MITM position, and no public exploit code was identified at time of analysis. Impact is limited to integrity (CVSS 6.3, high attack complexity) with no confidentiality or availability effect.
Improper TLS certificate validation in GlitterWare Passy through 1.10.1 lets an unauthenticated attacker who already holds an on-path network position impersonate HTTPS hosts and intercept or alter traffic the app exchanges. Exploitation is rated high complexity because the attacker must actively man-in-the-middle a connection at the moment Passy connects, but no user interaction is required; no public exploit was identified at time of analysis. Upgrading to 1.10.2 removes the insecure global HTTP override and restores certificate validation.
Improper TLS certificate validation in fatfree-core through 3.9.2 leaves outbound HTTPS requests made through the framework's HTTP client open to man-in-the-middle attacks. The flaw hard-disables CURLOPT_SSL_VERIFYPEER in web.php's _curl function, but exploitation is difficult: it requires the application to use this client for outbound HTTPS and an attacker to hold an active MITM position, and impact is limited to data transmitted through that client. The vendor released 3.9.3 with commit a2c755c, and no public exploit code or active exploitation is reported; this is a medium-severity, low-urgency issue rather than an emergency.
Local information disclosure in Dell Application Installer before 26.09.0.1 exposes sensitive data that the product stores without encryption, allowing any local user on the host to read it without authentication (CVSS 6.2, PR:N). The flaw requires local access to the affected machine but no privileges or user interaction, so shared, multi-user, or physically accessible Dell systems are the primary exposure surface. No public exploit code or active exploitation has been identified at time of analysis, and Dell has released version 26.09.0.1 to remediate the issue.
A heap/stack buffer overflow in fastllm (versions up to and including 0.1.8.2) lets remote attackers corrupt memory by supplying a crafted GGUF model file whose string-length field is manipulated, triggering an out-of-bounds write inside GGUFBuffer::ReadString in third_party/gguf/gguf.cpp. Exploitation requires the victim to load or parse the malicious model (user interaction, CVSS UI:P/UI:R), and no authentication is needed; impact is limited to partial confidentiality, integrity, and availability loss. Publicly available exploit code exists (a POC archive is linked alongside the VulDB entry and upstream GitHub issue 759), but there is no CISA KEV listing, so active in-the-wild exploitation is not confirmed; the vendor has not yet responded to the report.