An authenticated user who is permitted to submit evaluation jobs in Red Hat OpenShift AI's lm-evaluation-harness component can supply an attacker-controlled model URL in the JobSpec, causing the evaluation job pod to send the tenant's model authentication secret to an external listener the attacker controls. The same user-controlled URL handling allows Server-Side Request Forgery against internal endpoints reachable from the evaluation pod's network namespace, so internal services can be probed or reached with the pod's network position rather than the attacker's. The impact is confidentiality-only (CVSS 3.1 base 6.5, PR:L, C:H/I:N/A:N), no public exploit code or confirmed active exploitation was identified at time of analysis, and exploitation is gated on valid tenant job-submission credentials plus network reachability from the pod.
Cross-tenant role manipulation in hMailServer 6.3.4 through 6.3.6 allows an authenticated credential confined to named domains - either a full-scope REST API key issued for those domains or a serveradmin account assigned a domain list - to create, rewrite, or delete custom roles globally through the REST role-management routes. Because those routes require manage_roles and name no domain, the authorization gate does not scope the operation to the caller's tenant, so an attacker can raise or lower the permissions of a custom role assigned to another domain's accounts; the reachable damage is bounded because custom roles cannot carry administer_server, administer_domain, or manage_roles. No public exploit identified at time of analysis, and exploitation is meaningful only in multi-tenant deployments where custom roles are assigned across domains.
NLnet Labs Unbound up to and including 1.26.1 can be tricked into downgrading a validly signed island-of-security zone to insecure status by a forged NXDOMAIN response, allowing an attacker to deny the existence of records inside that trusted island. The flaw only manifests in the non-default configuration where a root trust anchor and an explicit 'trust-anchor:' statement for an island-of-security zone are both present and the island's parent is provably insecure under the root chain; the attacker must also be positioned to deliver a crafted NXDOMAIN carrying an NSEC/SOA RRSIG whose SignerName names the insecure parent. No public exploit code or confirmed active exploitation was identified at time of analysis, and the high attack complexity and specialized configuration keep practical risk moderate (CVSS 6.5, AV:N/AC:H/PR:N/UI:N/C:N/I:L/A:H).
Splunk SOAR (On-premises) deployments below 8.7.0 allow an authenticated user with REST API access to alter the Enterprise Security edition and trigger an unauthorized license change, because the application authenticates the request but fails to authorize the caller before applying the change. The flaw is an integrity-only issue (CVSS 6.5, PR:L) and does not expose data or disrupt availability; no public exploit code or confirmed active exploitation was identified at time of analysis.
Apache bRPC through 1.17.0 can be remotely aborted by an unauthenticated attacker who sends a crafted HTTP/2 HEADERS block that exhausts the HPACK dynamic-table ring buffer while staying under the byte-based eviction threshold. The h2 parser is enabled by default on bRPC server ports and processes headers before Authenticator checks, so any exposed h2/gRPC listener is sufficient; the assessed impact is availability-only (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H). No public exploit identified at time of analysis, and no KEV listing or EPSS score was present in the supplied data.
Cross-site request forgery in the Tailored Tools WordPress plugin (versions up to and including 3.0.3) lets an attacker who can lure a logged-in privileged WordPress user - typically an administrator - to a malicious page or link silently perform state-changing actions that the victim's session is authorized to make. The attacker needs no account of their own (CVSS 6.5, AV:N/PR:N/UI:R), but the attack only succeeds if the victim is authenticated at the moment of interaction, so confidentiality is unaffected while integrity impact is rated High. Reported by Patchstack; no public exploit code or confirmed active exploitation was identified at time of analysis.
Missing authorization (CWE-862) in the BjornTech Swish for WooCommerce WordPress plugin at versions up to and including 3.7.8 lets unauthenticated remote attackers reach plugin endpoints that perform no access-control check, yielding limited reads and modifications of the protected Swish payment functionality (CVSS 6.5, AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N). Only WooCommerce stores running this Sweden-specific Swish mobile-payment integration are exposed, so the practical attack surface is narrow geographic/vertical footprint rather than mass exploitation. No public exploit code has been identified at time of analysis, no CISA KEV listing applies, and no EPSS score was supplied with the source data.
Stored cross-site scripting in the Contest Gallery WordPress plugin through version 34.0.1 allows an authenticated low-privilege user to persist malicious markup that later executes in another user's browser when the tainted page is rendered. Because the injected script runs in the victim's context (scope changed, C:L/I:L), an attacker could perform limited actions as the viewer, such as altering displayed content or bypassing page-level protections. No public exploit code was identified at time of analysis, and the issue has not been confirmed actively exploited (CISA KEV).
Heap-based memory corruption in NTPsec ntpd before 1.2.6 affects deployments that explicitly enable the non-default JJY refclock driver in Telephone JJY mode (refclock type 40). An unauthenticated attacker with physical/local control of the Telephone JJY time source can send more than six time replies to the driver, causing heap corruption, an ntpd crash, and high integrity/availability impact; the CVSS score is 6.4 but real-world priority is low because stock configurations do not enable this region-specific driver. No public exploit code was identified at time of analysis.
Pillow 11.2.1 through 12.x can disclose uninitialized padding, bytes preceding the first row, or stale heap contents when an application sets a non-default PILLOW_ALIGNMENT and exports images through the Arrow C interface (__arrow_c_array__/__arrow_c_schema__). The flaw is limited to deployments that both customize alignment and use Arrow export, with meaningful cross-user exposure requiring a multi-user context where one user's exported buffer can reach another user; default Pillow configurations are not affected. No public exploit code or CISA KEV entry was identified at time of analysis, and the vendor released Pillow 13.0.0 as the fix.
Pydantic AI Harness versions before 0.59.0 fail to enforce the operator-configured UsageLimits.tool_calls_limit for nested tool invocations dispatched from inside a sandboxed run_code snippet in the CodeMode toolset, letting a program call run_nested_call() repeatedly and reach costly or side-effecting tools far beyond the intended ceiling. Unauthenticated remote attackers who can shape the agent's execution - as a user of the agent or through prompt-injected content - can therefore bypass a guardrail that operators rely on for cost and safety control, with impact bounded to resource exhaustion/limit violation rather than data exposure or code execution. This is a moderate CWE-770 resource-throttling flaw; no public exploit code or active exploitation was identified at time of analysis, and the vendor has released 0.59.0 to correct it.
Improper authorization in the HarnessRouter gateway through version 0.31.10 lets a request that carries the internal key plus a non-verifying bearer token assert arbitrary X-Harness-Org and X-Harness-Member identity headers, because the gateway's default identity mode was 'observe' rather than a fail-closed 'enforce'. This enables cross-tenant impersonation of any organization or member, with Low confidentiality, integrity, and availability impact; the attack is remote but rated high complexity and difficult to exploit, and no public exploit code or active exploitation has been identified at time of analysis. HarnessRouter 0.31.11 changes the default to 'enforce' and closes the issue.
Route-rule matching in Nuxt versions prior to 4.6.2 can be evaded by changing only the letter case of a request path, because Nuxt's page resolver is case-insensitive by default while Nitro's server-side route-rule keys are matched case-sensitively. A remote, unauthenticated attacker who requests a case-variant of a protected route can cause redirects, custom headers, proxy rules, ssr: false and noScripts to be skipped, and can make getRouteRules(event)/matchRouteRules return no rule at all for that path. This is a configuration-dependent security-control bypass rather than a high-urgency flaw: applications that set router.options.sensitive: true in nuxt.config are unaffected, and access checks implemented in server middleware, page route middleware or page data fetching remain independent and are not bypassed. No public exploit code or confirmed active exploitation was identified at time of analysis; the issue is addressed by the vendor fix in 4.6.2.
Concurrent constrained-decoding traffic against vLLM servers running versions before 0.31.0 can leave a stale token allowlist in a recycled batch slot, so a victim's unrestricted generation request is silently constrained to the attacker's token set. The flaw is in InputBatch.condense(), which recycles finished request slots without clearing allowed_token_ids; remote unauthenticated attackers who can reach the generation API, including the unauthenticated /invocations endpoint, can trigger it by submitting many concurrent constrained requests while a race with slot reuse is won. Impact is integrity-only - the victim's output is degraded or steered, but no victim data is read - and success is timing- and load-dependent (CVSS AC:H with attack requirement AT:P). No public exploit code or confirmed active exploitation has been identified at time of analysis, and the issue is fixed in vLLM 0.31.0.
Contracts written in Vyper 0.3.8 through 0.5.0b1 that use a ternary expression to select between nested arrays with differing inner bounds can silently store corrupted values or revert at runtime, because the compiler emits code that reads the narrower arm using the wider result type's memory layout. Only deployments that already contain this specific widening nested-array ternary pattern are exposed, and no public exploit code has been identified at time of analysis. The impact is confined to the integrity of the affected contract's own state (CVSS 4.0 6.3 Medium, VI:L with no confidentiality or availability impact), so contracts lacking the pattern are entirely unaffected.
Factories compiled with Vyper 0.3.4 through 0.5.0b1 that forward an attacker-influenced code_offset into the create_from_blueprint builtin can be tricked into deploying contracts with zero runtime code. The compiler computes the remaining blueprint size with unchecked uint256 subtraction, so an offset larger than the blueprint's code size wraps to a small positive number and the copy silently yields empty bytecode; assets sent to the resulting codeless address, or initialization logic that assumes a working contract, can be permanently trapped. Impact is conditional rather than universal: only factories that both use this builtin and expose code_offset to callers are reachable (reflected in the assessed CVSS 3.1 vector AV:N/AC:H/PR:N/UI:N/C:N/I:L/A:L), no public exploit code has been identified at time of analysis, and no CISA KEV entry exists, so this is a moderate, conditional risk rather than a drop-everything priority.
Coraza WAF before 3.8.1 can be induced to record a decoy multipart filename for FILES-based inspection while a downstream application receives a different, attacker-chosen name, allowing upload-name restrictions to be bypassed when the backend honors RFC 5987 filename* parameters. The root cause is Go's mime.ParseMediaType, which silently discards filename* values whose charset is not us-ascii or utf-8, so a header such as filename*=iso-8859-1''shell.php is either masked by a benign plain filename or, when filename* appears alone, causes the part not to be classified as a file upload at all. Exploitation is unauthenticated but requires both FILES/FILES_SIZES-based Coraza rules and a backend that itself parses filename*, and no public exploit identified at time of analysis.
Out-of-bounds write in the Zephyr RTOS Nuvoton NPCX/NPCK eSPI Target-Attached-Flash driver lets an eSPI host that sends a flash write or RPMC OP1 request with an oversized 12-bit header length field push up to roughly 956 bytes of attacker-influenced data past a fixed 16-word buffer in .bss, and also causes up to 4 KB of adjacent controller SRAM to be programmed into SPI flash at a host-chosen address where the host can read it back. Only builds that explicitly enable CONFIG_ESPI_TAF on NPCX/NPCK silicon are exposed - no in-tree Zephyr board turns the option on by default - and the trigger requires host firmware or bus-level control of the eSPI link rather than ordinary host software, which is consistent with the assessed CVSS 6.3 vector (AV:L/PR:H). No public exploit code was identified at time of analysis, and the vendor has published a patched commit plus a GitHub security advisory.
IP spoofing in Go Chi before 5.4.0 allows an unauthenticated client that can reach the Go server directly to forge its apparent source address through the opt-in ClientIPFromXFF middleware. The middleware skips X-Forwarded-For entries that fall inside a configured trusted CIDR but never verifies that the direct TCP peer in http.Request.RemoteAddr belongs to that same CIDR, so an attacker can append a trusted-looking proxy address and control the value returned by middleware.GetClientIP. This is a moderate-severity logic flaw (CWE-348) that matters only where applications use the derived client IP for allowlisting, rate limiting, geolocation, or audit logging; no public exploit identified at time of analysis.
Deeply nested JSON or JSONC documents fed into stream-json's FlexAssembler between versions 2.0.0 and 3.6.x can pin the Node.js event loop at full CPU, stalling every other operation in the host process. The trigger is the assembler's string and regular-expression path rules, which rebuild a full key-path string on every container start, so nesting depth D produces D joins of average cost D - quadratic work on a single thread. No credentials, no schema knowledge, and no user interaction are required (PR:N/UI:N), and the impact is availability only (C:N/I:N/A:H), making this a moderate operational-availability concern rather than an RCE or data-exposure emergency; no public exploit code was identified at time of analysis. Version 3.7.0 fixes the issue by adding a default maxDepth of 1024 that throws a RangeError for over-deep containers.
An out-of-bounds read in libmodulemd's modulemd v2 rpm-map YAML serialization path can crash applications that process crafted module metadata, producing a local denial of service. The bug is triggered only when the metadata declares multiple digest algorithm types and is serialized through the affected path; default single-digest metadata does not trigger it. The assessed impact is availability-only, with no confirmed code execution or data exposure, and no public exploit code or CISA KEV entry was identified at time of analysis.
Stack exhaustion in libmodulemd's xmd (extended metadata) parser lets anyone who can place crafted modulemd YAML in front of a consuming process crash it or exhaust its resources, an availability-only denial of service (CVSS 6.2, C:N/I:N/A:H). The defect is in the recursive YAML mapping/sequence helpers that convert xmd content into nested GVariant values with no recursion-depth or node-count ceiling, so deeply nested input overflows the stack. Affected builds ship in Red Hat Enterprise Linux 8, 9 and 10, Red Hat Hardened Images, and OpenShift Container Platform 4; the vector AV:L/PR:N/UI:N means the attacker must first get the malicious metadata onto a host that parses it (for example an attacker-controlled or third-party module repository consumed by DNF/libdnf), after which no authentication or user interaction is required. No public exploit code and no confirmed active exploitation were identified in the available intelligence at time of analysis.
Denial of service in libmodulemd can be triggered when a build compiled with rpmio support parses a highly compressible modulemd YAML file; the custom decompression read handler does not cap cumulative decompressed output before parsing, allowing CPU and memory exhaustion that can hang or crash the consuming process. The issue is scored CVSS 6.2 with a LOCAL vector, requires no authentication or user interaction once a malicious file reaches the parser, and is associated by CPE data with Red Hat Enterprise Linux 8, 9, and 10 plus related OpenShift and hardened image products. No public exploit code or CISA KEV-listed active exploitation was identified in the supplied intelligence.
Arbitrary file creation in BusyBox's libarchive component allows attackers to write files outside the intended extraction directory by supplying a crafted archive containing symlink or traversal path entries, triggered when a target user opens the malicious file (ZDI-CAN-27556). The CVSS 3.1 vector AV:L/AC:L/PR:N/UI:R scores 6.1, reflecting a local attack path that requires user interaction, no confidentiality impact, high integrity impact, and low availability impact, with writes confined to the privileges of the extracting process. No public exploit code has been identified at time of analysis, and real-world priority is low-to-moderate except in automated or server-side pipelines that unpack untrusted archives without human vetting.
Path traversal in OpenSCAP's Source DataStream (SDS) decomposition can allow a crafted datastream to create or modify files outside the intended output directory with the permissions of the process performing the decomposition. The issue affects OpenSCAP as shipped in Red Hat Enterprise Linux 6 through 10 and Red Hat Hardened Images; exploitation is local and requires the victim user or automated system to decompose an attacker-supplied SDS containing directory traversal sequences. No public exploit code or CISA KEV entry was identified at time of analysis, and the CVSS 3.1 score is 6.1 (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:L).
Trigger.dev before 4.5.6 allows cross-tenant deployment hijacking: an attacker holding any valid environment API key can POST a victim's deployment friendlyId to the background-workers endpoint and re-point an in-progress deployment to a worker in the attacker's environment. The flaw is an IDOR/CWE-639 in createDeploymentBackgroundWorkerV4, which resolves deployments by friendlyId without environment, project, or organization scoping; exploitation requires knowing the victim friendlyId and hitting the deployment while it is still in progress. Vendor patch 4.5.6 is available, and no public exploit identified at time of analysis.
Cross-site scripting (CWE-79) in odf-kit 0.10.0 through 0.14.1 lets unauthenticated remote attackers inject HTML or script through crafted ODF style properties such as fo:color, which the ODT-to-HTML renderer concatenates unescaped into style attributes. The issue is exploitable only when a consumer converts an attacker-controlled ODT/ODS document to HTML and then displays that output in a browser or other HTML-rendering context, requiring user interaction (CVSS 6.1, AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N). No public exploit code was identified at time of analysis, and version 0.14.2 contains the fix.
Memory exhaustion in pypdf before 6.20.0 occurs when an application decodes a crafted PDF stream that declares an excessive number of filters or chains multiple filters that repeatedly pass large data, driving uncontrolled memory consumption and potential denial of service. The attacker must supply a malicious PDF and get the application to reach the stream-decoding path; authentication against the library is not required (PR:N), while the assessed vector reflects user interaction and attack requirements. The vendor fixed the issue in pypdf 6.20.0; no public exploit identified at time of analysis and no confirmed active exploitation were provided.
An infinite loop in pypdf's standard cross-reference table parser allows a crafted, truncated PDF to hang any Python application that parses untrusted documents with versions prior to 6.20.0. Because the parser does not validate that xref entry lines are the expected 20 bytes before consuming them, a file that ends mid-table drives the reader into a non-terminating loop, exhausting CPU and blocking the processing thread. Only availability is affected - no disclosure, modification, or code execution - and the attack requires the victim application to actually ingest the malicious file (CVSS 4.0 6.0; independent assessment agrees with high availability impact). No public exploit code or CISA KEV entry was identified at time of analysis.
Denial of service in pypdf versions prior to 6.20.1 occurs when crafted cyclic PDF outline or /Next tree structures are processed by writer-side object removal, causing an infinite loop that blocks the current process. Applications are affected only if they accept attacker-supplied PDFs and invoke tree/node removal paths such as find_outline_item or _remove_node_from_tree; merely opening or reading a PDF is insufficient. The vendor advisory GHSA-9mx8-4j7g-633p and PR #4188 address the issue by adding cycle detection, and upgrading to 6.20.1 resolves it; no public exploit or CISA KEV confirmation is present in the provided data.
Denial of service via infinite loop in pypdf's writer-side outline lookup: calling PdfWriter.find_outline_item on a crafted PDF whose document outline contains a cyclic hierarchy (looping /First or /Next pointers) causes the function to recurse or iterate indefinitely, hanging the calling Python process. All pypdf releases prior to 6.20.1 are affected; the exposure is limited to applications that both accept untrusted PDFs and specifically invoke this writer method, since documents that are only opened or read do not trigger the flaw. Impact is availability-only (process hang), with no memory corruption, data disclosure, or code execution; no public exploit code has been identified at time of analysis, and the issue does not appear in CISA KEV.
Apache Pulsar 2.8.0 through 4.2.x deployments that enable package management allow an authenticated user to read package contents belonging to another tenant by supplying a crafted package URL when registering or updating a function, source, or sink. The Functions worker validates the caller's rights only on the namespace where the component is being created, then retrieves the referenced package from the Packages Management Service using the worker's own broker credentials, so the package ACL is evaluated against the worker instead of the requesting user (CWE-863, confused deputy). Impact is limited to confidentiality - package code, business logic, or embedded credentials may be disclosed - with no modification, deletion, or availability effect; exploitation requires authentication/authorization and non-default package-management settings, and no public exploit was identified at time of analysis.
Memory exhaustion in pypdf versions prior to 6.21.0 allows unauthenticated remote attackers to cause denial of service by supplying a crafted PDF whose content stream contains a very large number of small operations. Default parsing in affected versions imposes no cap on array/dictionary element counts or total parsing work, so an application that reads untrusted PDFs can be driven to consume large amounts of memory; user interaction is required in the sense that a crafted PDF must be opened or processed. This is an availability-only issue rated 6.0 (CVSS 4.0, medium), and no public exploit code or confirmed active exploitation was identified in the provided data.
Memory exhaustion denial of service in pypdf versions prior to 6.21.0 allows an attacker-supplied PDF to drive parsing into unbounded memory consumption by embedding arrays or dictionaries with very large element counts. Only applications that actually ingest and parse untrusted PDFs through the library are exposed, since pypdf is a pure-Python component rather than a network service; no credentials are needed to craft or deliver the file (PR:N, UI:R/UI:P). The vendor has released pypdf 6.21.0 with configurable element-count and parsing-budget caps; no public exploit code or confirmed active exploitation was identified at time of analysis, and the CVSS 4.0 base score is 6.0 (medium) with availability-only impact.
Denial of service in pypdf versions before 6.21.0 can be triggered when an application parses an attacker-crafted PDF and retrieves its form fields, causing excessive memory consumption or long runtimes through unbounded AcroForm field-tree traversal. The flaw is availability-only (CWE-400), requires the consuming application to accept untrusted PDFs and actually query form fields, and needs no authentication against the parsing code; no public exploit was identified at the time of analysis. The vendor has released pypdf 6.21.0, which adds limits on form-field entry count and traversal depth.
Authenticated low-privilege users of Velneo vServer can disclose server-side files readable by the vServer process through improper link resolution before file access, a symlink/link-following flaw. The issue affects vServer releases from 32.3 before 36.6 and from 37.1 before 37.2; exploitation requires a valid low-privileged account and a specific precondition to induce server-side path resolution of an attacker-influenced link. The vendor CVSS 4.0 base score is 6.0 and the independent assessment is moderate with confidentiality-only impact; no public exploit was identified at time of analysis, and a vendor patch is available through Velneo security advisories.
Cross-tenant run replay in Trigger.dev versions before 4.5.0 allows any authenticated tenant holding a valid API key to replay another customer's run into their own runtime environment and read the victim's task payload. The api.v1.runs.$runParam.replay route resolves runs by friendlyId alone without scoping the lookup to the caller's environment, so exploitation requires knowledge of the victim's specific friendlyId rather than being broadly enumerable. Impact is bounded to confidentiality (payload disclosure, no integrity or availability effect) and is most relevant in shared or multi-tenant hosted deployments; the vendor has released a fix in 4.5.0, and no public exploit code has been identified at time of analysis.
Numeric literal manipulation in the Vyper smart-contract compiler (versions 0.1.0b1 through 0.1.0b16 and 0.4.1 through 0.5.0b1) lets attacker-supplied source silently alter address, integer, and decimal constants that survive into compiled bytecode. The compiler builds its source-line table with str.splitlines(), which recognizes line separators such as form feed (U+000C) and U+2028 that the Python parser ignores, so literals are classified and validated against a shifted view of the source. Exploitation requires a victim to compile and deploy malicious-looking-but-reviewed code (unauthenticated remote attacker, user interaction required per the assessed vector CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:N), and no public exploit code or confirmed active exploitation has been identified at time of analysis; this is a medium-severity integrity issue, not an urgent remote-code-execution priority.
Source-code integrity compromise in the Vyper compiler allows attacker-supplied Vyper source to silently substitute numeric literals, addresses, and other constants during compilation. Affected versions are Vyper 0.1.0b1 through 0.1.0b11, 0.1.0b14, and 0.4.1 through 0.5.0b1; exploitation requires the victim to compile source containing either a non-ASCII identifier that NFKC-normalizes to ASCII or an invisible byte-order mark, which triggers a character-versus-byte offset mismatch in literal reconstruction. No public exploit code identified at time of analysis, and the flaw does not affect already-compiled trusted contracts or expose a remote network service.
Information disclosure in Splunk SOAR (on-premises) versions below 8.7.0 allows an unauthenticated remote attacker who already holds encrypted credential data from the instance to submit those values as HTTP Basic authentication to the REST API and have SOAR decrypt them before authentication checks complete. The vendor states this cannot be exploited at will because prior access to the encrypted credential store is required, and the CVSS 5.9 score (AC:H) reflects that precondition; no public exploit code or active exploitation is identified in the supplied data.
hMailServer 6.0.0 through 6.3.6 can be induced to forward or redistribute mail under an SMTP identity that satisfies the hosted domain's own SPF and DMARC checks, so a remote, unauthenticated attacker can write a message whose From names a domain the server hosts and have it delivered to outside receivers as DMARC-passing. The flaw is configuration-dependent: it requires a forward, Sieve redirect, alias or mailing list that carries hosted-domain mail to an external address, plus one of several additional conditions (SRS or envelope-sender rewriting enabled - both off by default - a list bounce address inside the domain's organization, a subdomain envelope sender whose SPF authorizes the server, or an empty envelope sender with an SPF-authorized hostname). Scored CVSS 5.9 (AC:H, no confidentiality or availability impact, high integrity impact); at time of analysis no public exploit code was identified, and the vendor addressed the issue in release 6.3.7.
TP-Link Archer C6 V2 routers use a device-universal hardcoded cryptographic key to protect exported configuration backups and stored credential data, so anyone who obtains such an encrypted artifact can decrypt it and recover plaintext administrative credentials. This is a moderate-severity confidentiality issue (CVSS 4.0 base 5.9; assessed CVSS 3.1 AV:L/AC:H/PR:H/UI:N/S:U/C:H/I:N/A:N) because exploitation requires possession of the encrypted configuration file-typically after an administrative export, backup leak, support/RMA exposure, or prior compromise-rather than direct remote decryption. No public exploit has been identified at time of analysis, and TP-Link has released updated firmware for Archer C6 V2.
Domain spoofing in Progressive Robot hMailServer 6.0.0 through 6.3.6 allows a remote unauthenticated attacker to have messages sent with an envelope sender at a domain the server hosts, bypassing SPF and DMARC checks at receiving systems. Exploitation depends on a pre-existing hosted account that collects mail from an external POP3/IMAP mailbox and forwards or redirects it to an outside address, and on the attacker knowing such a mailbox; the High attack complexity reflects that prerequisite rather than any authentication requirement. No public exploit code was identified and the issue was not listed in CISA KEV at time of analysis.
Unauthenticated remote attackers can force the Snort 3 Detection Engine in Cisco Secure Firewall Threat Defense, Cisco UTD Snort IPS Engine, and open-source Snort 3 to restart by sending crafted VBA data through traffic the engine inspects, producing a denial-of-service condition. The flaw is a stack-based buffer overflow (CWE-121) caused by improper range checking in the Snort 3 VBA Decompression Engine; exploitation requires Snort 3 inspection with VBA decompression enabled and visibility of attacker traffic. No public exploit was identified at time of analysis, and the assessed impact is limited to availability with a CVSS score of 5.8.
Antivirus attachment-stripping in Progressive Robot hMailServer 6.0.0 through 6.3.6 fails open, letting a remote unauthenticated sender have content the server's own virus scanner flagged as infected delivered unchanged into the recipient's mailbox. The bypass only triggers when virus scanning is enabled and the action is set to the non-default 'remove attachments and deliver the text' mode; messages crafted as a single non-text MIME part (a bare program or archive as the whole message, a whole forwarded message, a file declared as the sole attachment, or a one-part S/MIME-signed message) give the stripping routine no text part to isolate and are delivered as they arrived, leaving only an application-log line as evidence. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; practical harm additionally depends on the recipient's mail client opening the delivered content.
Memory management flaws in Cisco Snort 3's file-processing path allow remote, unauthenticated attackers to exhaust memory and force unexpected Detection Engine restarts, interrupting packet inspection on affected open-source Snort 3 and Cisco Secure Firewall Threat Defense deployments. The issue is rated CVSS 5.8 (moderate) with a scope change and availability-only impact; no public exploit was identified at time of analysis, and Cisco has published an advisory. Sustained delivery of files to an inspection point with file policy enabled is required, so exposure is greatest on inline sensors actively inspecting untrusted traffic.
Improper handling of nested GRE traffic in the Snort 3 Detection Engine allows unauthenticated, remote attackers to crash and restart the engine by sending a crafted GRE payload through an affected device, causing either an inspection bypass or a transient denial of service depending on how the device is configured. Affected deployments include Cisco Secure Firewall Threat Defense (FTD), the Cisco UTD Snort IPS Engine, Cisco Cyber Vision, the Cisco Umbrella Insights virtual appliance, and open-source Snort 3. No public exploit code or confirmed active exploitation was identified at time of analysis; the engine restarts automatically, so disruption is transient per triggering packet, keeping this a moderate-severity availability issue rather than a top-tier priority.
Cisco Snort 3's Teredo detection engine can be forced to restart by a crafted Teredo packet, interrupting packet inspection on Cisco Open Source Snort 3, Cisco Secure Firewall Threat Defense (FTD) Software, and Cisco UTD Snort IPS Engine Software deployments that actually inspect Teredo traffic. The issue is remotely reachable without authentication or user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:N/A:L), but impact is availability-only: a temporary engine restart and inspection gap rather than persistent compromise or code execution. No public exploit was identified at time of analysis, and exploitation depends on the target's Snort engine receiving and parsing Teredo packets.
Crafted GRE packets can cause Cisco Snort 3's Detection Engine to restart, temporarily interrupting packet inspection in Cisco Secure Firewall Threat Defense, the Cisco UTD Snort IPS engine, and open-source Snort 3 deployments that inspect GRE traffic. The issue is incomplete error checking during GRE parsing and is reachable by unauthenticated remote attackers with no user interaction (CVSS 3.1: AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:N/A:L). No public exploit was identified at time of analysis, and the practical constraint is that the malicious GRE packet must traverse a Snort-inspected path.
Denial of service in Cisco Snort 3 allows an unauthenticated, remote attacker to restart the detection engine by sending a single crafted UDP NetFlow packet, interrupting packet inspection. The issue affects Cisco Open Source Snort 3, Cisco Secure Firewall Threat Defense (FTD) Software, and Cisco UTD Snort IPS Engine Software when NetFlow detection is active and the crafted packet reaches the parser; Cisco rates it CVSS 5.8 (AV:N/AC:L/PR:N/UI:N/S:C/A:L). This is a moderate-priority availability issue, with no public exploit identified at time of analysis, and exploitation depends on NetFlow traffic being in the sensor's inspection path.