An authenticated remote user of IBM Concert versions 1.0.0 through 3.0.0 can degrade or deny service availability by driving storage consumption past the limits the product is supposed to enforce. The vulnerability is rated CVSS 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H), meaning the attacker needs a valid account and network reachability to the Concert service but no user interaction; the only impacted security property is availability, with no confidentiality or integrity loss. Exploitation requires the improperly enforced storage limits tracked as CWE-400 to be exhausted, so the practical effect is resource exhaustion leading to denial of service. There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV), and a vendor patch is published, which materially lowers the urgency of this availability-only issue.
Authenticated path traversal in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift lets a remote attacker holding a valid FTM account manipulate file paths in a file-handling operation so that files are written or modified outside the intended directory. Because the flaw requires authentication and yields only limited integrity and availability impact - with no confidentiality exposure and no user interaction - it scores 5.4 and represents a medium-severity, low-priority issue rather than a high-urgency one. A vendor patch is available via IBM support node 7288641, and no public exploit code has been identified at time of analysis (no CISA KEV listing).
Authorization-boundary bypass in MCP Atlassian (sooperset/mcp-atlassian) versions prior to 0.22.0 lets an authorized MCP caller search Jira projects and Confluence spaces that fall outside the administrator-configured allowlist, by supplying caller-controlled projects_filter/spaces_filter arguments that replace the operator's restriction or by embedding an explicit project/space clause that suppresses it. Rated CVSS 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), exploitation requires an already-authorized MCP caller plus a shared Atlassian credential whose access extends beyond the allowlist; the result is read-only information exposure with no integrity or availability impact. No public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV); vendor-released patch: 0.22.0.
Memory exhaustion denial of service in Mattermost 11.7.x through 11.10.x allows an authenticated user to send oversized request bodies to plugin endpoints because the CSRF-validation path fails to enforce a request body size limit. The affected ranges are 11.7.x up to and including 11.7.10, 11.8.x up to and including 11.8.5, 11.9.x up to and including 11.9.1, and 11.10.x up to and including 11.10.1. This is an availability-only issue rated CVSS 6.5, with authentication required (PR:L) and no public exploit identified at time of analysis.
Improper authorization controls in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift let an authenticated, low-privilege user forge identities and act as another user across the network, bypassing the platform's security checks. Only integrity is affected - an attacker can perform unauthorized actions under a spoofed identity, but there is no exposure of confidential data and no denial-of-service impact, and a valid account on the FTM instance is a prerequisite (PR:L, so the flaw is not exploitable pre-authentication). No public exploit has been identified at time of analysis and the issue is not listed in CISA KEV; with a CVSS base of 6.5 and a narrow deployment footprint in financial transaction environments, it is a genuine but moderate-priority issue.
IBM Financial Transaction Manager (FTM) for Red Hat OpenShift contains an XML external entity (XXE) flaw that lets an authenticated, low-privilege user who can reach an XML-accepting endpoint coerce the application's XML parser into resolving attacker-supplied external entity references, resulting in disclosure of sensitive information such as local files or internal service responses. Per the CVSS vector (AV:N/AC:L/PR:L/UI:N/S:C) the attack is network-reachable but requires a valid low-privilege account and an application code path that parses untrusted XML with external entity/DTD resolution left enabled, and our independent assessment scores the impact as confidentiality-only (C:H/I:N/A:N) rather than the vendor's mixed confidentiality/integrity rating. Exploitation is gated by authentication and by the presence of a suitable XML-processing entry point, and no public exploit identified at time of analysis; a vendor patch is available, which together keep this a mid-severity, configuration-dependent information-disclosure issue rather than an urgent priority.
Remote unauthenticated attackers can perform unlimited password guessing against the pH7Builder (pH7 Social Dating CMS) administration login through version 19.2.0 by bypassing the CAPTCHA, which is only rendered when the PHP session flag captcha_admin_enabled is set. Publicly available exploit code exists, and the bypass chain is detailed in a third-party blog, though the EPSS score is low at 0.38% (31st percentile) and CVSS 3.1 base score is 6.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N). The practical impact is limited to enabling brute-force attempts; strong admin passwords or an external rate limiter materially reduce risk.
IBM Financial Transaction Manager (FTM) for Red Hat OpenShift ships with missing server-side authorization checks on payment-mutation functions, letting a low-privileged authenticated user invoke actions reserved for higher-privileged roles. The flaw is network-reachable and low-complexity (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N, 6.5 Medium), with the damage confined to integrity - unauthorized modification or execution of payment transactions - and no confidentiality or availability impact. Exploitation requires a valid FTM for Red Hat OpenShift account (PR:L) plus reachability of the affected payment endpoints; no public exploit code or confirmed active exploitation has been identified at time of analysis, and the vendor has published a fix.
Unauthenticated remote attackers can authenticate to the password-reset workflow of OpenEye Apex Network Video Recorder (NVR) firmware 3.2.9.376 using a hardcoded, shared recovery credential (CWE-798) that cannot be changed, disabled, or rotated. This flaw has been present since at least firmware 2.2.3.4 and grants only access to the password-reset workflow, not normal administrator privileges; full admin takeover requires chaining additional vulnerabilities. The CVSS 3.1 score is 6.5 (MEDIUM) with LOW confidentiality and integrity impact, and no public exploit code has been identified at time of analysis. Upgrade to firmware 3.5.4 to remediate.
Unauthenticated attackers can defeat the IP-based administrative login throttling in pH7Software pH7Builder (pH7 Social Dating CMS) through version 18.2.0 by sending a different X-Forwarded-For or Client-IP header with every request, allowing unlimited password-guessing attempts against the admin login. The CMS derives the client address from those attacker-controlled headers without verifying that the request came from a trusted proxy, so the per-IP failed-attempt counter and lockout never trigger. Exploitation requires only network reachability to the admin login endpoint and a standard HTTP client; the flaw is not confirmed actively exploited (not in CISA KEV), EPSS is low at 0.34% (27th percentile), and no public exploit code has been identified at time of analysis, although a third-party blog documents the bypass chain. The CNA-assigned CVSS 9.8 (C:H/I:H/A:H) substantially overstates the direct impact - the vulnerability only removes a brute-force control, so real-world risk hinges on whether valid admin credentials (weak or default passwords, no MFA) can subsequently be guessed.
Resource exhaustion in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift allows unauthenticated attackers on an adjacent network segment to force a denial-of-service condition by driving endpoint behavior that allocates resources without limits or throttling (CWE-770). The assigned CVSS 3.1 vector (AV:A/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 6.5) confines the attack surface to callers who can already reach a vulnerable FTM endpoint from the same network segment or cluster network, and limits the outcome to availability loss - service crash or hang - with no confidentiality or integrity impact. No public exploit code has been identified at time of analysis, the issue is not listed in CISA KEV, and IBM has published a vendor advisory with remediation guidance, making this a mid-severity availability issue rather than an urgent priority.
Server-side request forgery in IBM Concert 1.0.0 through 3.0.0 allows an attacker who holds valid credentials to make the application issue HTTP requests to URLs of their choosing, which can be used to enumerate internal network services and set up follow-on attacks. The impact is bounded: the assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N, 6.5 by the vendor) reflects limited confidentiality and integrity loss rather than code execution or arbitrary file read, and exploitation requires a reachable Concert feature that dispatches server-side requests to a user-influenced URL. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited (it is not in CISA KEV); IBM has published a fix via its support advisory.
HTTP response splitting in the Dancer2 Perl web framework before version 2.2.0 allows an attacker to inject arbitrary response headers and split an HTTP response when an application derives a response header NAME from request-controlled data: Dancer2's headers_to_array routine strips CR and LF from header values but not from names, so a crafted name reaches the PSGI server intact and, if that server does not validate header keys, the bytes following the CRLF are written to the wire as their own header line. The issue is unauthenticated and requires no user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N, 6.5 Medium), but exploitation is gated by two concrete application-specific preconditions - the app must reflect attacker input into a header key rather than a value, and the underlying PSGI server must fail to reject malformed keys - so default deployments are generally not vulnerable. No CISA KEV entry exists and no public exploit code was identified at time of analysis; EPSS is 0.19% (9th percentile) and CISA SSVC records exploitation as none and automatable exploitation as no, so all signals converge on low real-world priority despite the Medium CVSS.
Out-of-bounds read in the XS encoder of Perl's Net::IDN::Punycode (all versions before 2.590) lets a remote attacker who can influence a string passed to encode_punycode push a single byte from outside the module's 36-entry punycode digit table into the encoded result, or crash the calling process. The flaw is a signed-integer overflow of the punycode delta accumulator in the compiled XS backend; the pure-Perl PP backend is not affected, so exposure is limited to applications that have the XS module installed and feed it attacker-controlled labels, such as IDN/domain-to-ASCII conversion pipelines. Rated CVSS 6.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:L), impact is bounded to a one-byte information leak or a denial-of-service crash with no code execution or integrity impact, and no public exploit code has been identified at time of analysis; the vendor has shipped a fix in 2.590.
Local attackers with a low-privileged account on the host or container running IBM Financial Transaction Manager (FTM) for Red Hat OpenShift can read insufficiently protected credentials, potentially enabling lateral movement or further compromise. No public exploit was identified at time of analysis, and exploitation requires an existing local foothold-remote or unauthenticated access is not possible. Despite the MEDIUM 6.5 base score, this is a genuinely LOW-priority issue because it only affects confidentiality and benefits an attacker post-compromise.
Server-side request forgery in Cloudreve prior to 4.18.0 allows an authenticated user with remote-download privileges to bypass the ValidateExternalURL guard and make the server fetch loopback, private, link-local, or cloud-metadata IPv4 addresses that are wrapped inside IPv4-in-IPv6 transition forms - NAT64 64:ff9b::/96, 6to4 2002::/16, Teredo 2001:0000::/32, or the deprecated IPv4-compatible ::a.b.c.d - because the guard classifies the wrapper rather than the address actually reached. The vulnerability is reachable through SrcUri in RemoteDownloadTask.createDownloadTask and requires authentication (CVSS PR:L), so it is not remotely exploitable by an anonymous attacker; exploitation also depends on the fetch host's network actually routing the chosen transition form to the embedded IPv4, making NAT64, dual-stack, and cloud-hosted deployments the realistic targets. Where a cloud metadata service is reachable, a successful request can return internal service responses and expose instance credentials; no public exploit code has been identified at time of analysis, and the issue is fixed in version 4.18.0.
Privilege escalation in Amazon's amazon-connect-salesforce-lambda integration (all versions before 5.26) allows any authenticated AWS IAM principal that already holds lambda:InvokeFunction permission on the sfExecuteAWSService function to invoke it with caller-supplied service and API parameters, causing the function's own privileged execution role to perform AWS API operations that the caller's own identity is explicitly denied (CVSS 3.1: 8.1 High, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N; CWE-862 Missing Authorization). This is a confused-deputy flaw: it requires a pre-existing authenticated AWS foothold with invoke rights, cannot be reached anonymously, and needs no user interaction, and it only affects organizations that have deployed this specific Salesforce CTI integration. No public exploit code has been identified at time of analysis and there is no KEV listing; the vendor-released fix is v5.26, which introduces a SalesforceExecuteAWSServiceUser parameter to restrict who may invoke the function.
Stored cross-site scripting in the Contextual Related Posts WordPress plugin, affecting all versions up to and including 4.4.1, allows an authenticated user with author-level capabilities or above to inject arbitrary JavaScript into a page through the 'other_attributes' block parameter. The injected script is persisted and then executes in the browser of any visitor who later views the affected page, which is reflected in the CVSS 3.1 score of 6.4 (AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:N) where the scope change captures the impact spreading beyond the vulnerable component into the hosting site's origin. Exploitation is gated by the author-level account requirement and by the site using the Gutenberg block editor with the plugin active; no public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV.
Stored cross-site scripting in the Live Composer - Free WordPress Website Builder plugin affects all versions up to and including 2.1.21, allowing an authenticated attacker with contributor-level access or above to inject arbitrary JavaScript that executes for any user viewing the affected page. The flaw is rated CVSS 6.4 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:N) and stems from the dslc_module_downloads_output shortcode re-emitting attacker-controlled module fields without output escaping; the save-time wp_kses_post filter is evaded because the payload is persisted as a serialized string containing no HTML tags for kses to tokenize. No confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis; the practical constraint is that the attacker needs a contributor+ account and a victim must subsequently load the injected page.
Server-side request forgery in FastGPT versions prior to 4.15.2 lets an authenticated user with access to any server-side URL-consuming feature - a safe-Axios-backed HTTP tool, workflow HTTP node, external file-fetch integration, or similar integration - bypass the platform's built-in private-address block and reach loopback, private, link-local, or cloud instance-metadata services. The bypass works because the safe Axios interceptor in packages/service/common/api/axios.ts validates the hostname with isInternalAddress() before a separate HTTP connection performs its own DNS lookup, opening a time-of-check/time-of-use (DNS rebinding) window in which an attacker-controlled hostname resolves publicly during validation and to an internal address at connection time; the same independent re-resolution occurs after each manual redirect hop. Exploitation requires authentication, attacker-controlled authoritative DNS, and winning the resolution race, so while impact is high (read access to internal services and metadata, scope-changed), practical exploitation is non-trivial; no public exploit code or confirmed active exploitation was identified at time of analysis.
Memory corruption in the Primary Bootloader (PBL) of Qualcomm Snapdragon chipsets lets an attacker who has physical possession of a device feed a crafted ELF file during the early boot sequence and corrupt bootloader memory, with the scope change indicating a possible escape from the normal boot context into the secure/TrustZone world. Exploitation is highly constrained: CVSS 3.1 scores it 6.9 under a vector of AV:P/AC:H/PR:L/UI:R/S:C/C:H/I:H/A:H, meaning physical access, low-level privileges, high attack complexity (specific timing or hardware state) and user interaction are all required; the practical exposure is limited to lost or stolen devices, supply-chain interdiction, or forensic scenarios rather than remote or default network-reachable attacks. There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); Qualcomm has published a security bulletin (May 2026) covering the issue.
Privilege escalation in GNU C Library (glibc) 2.14 through 2.44 stems from a TOCTOU race in ld.so when expanding $ORIGIN in DT_RPATH for setuid/setgid (AT_SECURE) programs. A local low-privileged (PR:L) attacker can exploit this only where fs.protected_hardlinks is disabled and a suitable setuid/setgid binary exists, by hard-linking the binary and winning a race to swap an intermediate path component for a symlink so the loader loads an attacker-controlled shared object with the program's elevated privileges. No public exploit identified at time of analysis; major Linux distributions enable fs.protected_hardlinks by default, sharply limiting exposure.
Administrator password takeover in OpenEye Apex Network Video Recorder (NVR) firmware up to 3.2.9.376 is possible because the password-reset unlock-code scheme lacks a per-device secret or any server-side cryptographic material, allowing an attacker who reaches the privileged reset workflow to compute a valid unlock code entirely offline and reset the administrator password. Exploitation is not remote: it requires physical console access to the device and use of the privileged password-reset workflow (CVSS:3.1/AV:P/AC:L/PR:H/UI:N, score 6.2), so it is neither remotely reachable nor automatically triggered. No public exploit code and no confirmed active exploitation were identified at time of analysis; the vendor has released firmware 3.5.4 as the fix, and the vulnerable design has been present since at least firmware 2.2.3.4.
Stored cross-site scripting in Adobe Connect (server/web) and the Adobe Connect Android mobile app allows an attacker to plant persistent malicious JavaScript in vulnerable form fields, which then executes in a victim's browser when they view the page rendering that field. The vendor's vector rates it unauthenticated (PR:N), but our assessment holds that a practical attacker needs an account or role permitted to submit content into those fields, and the victim must actively browse to the affected page (UI:R). Impact stays confined to the victim's browser session (S:C with C:L/I:L - session/cookie theft, spoofed content, or actions as the victim), there is no server-side code execution or data-store compromise, no public exploit identified at time of analysis, and no CISA KEV listing; overall this is a genuine but modest, moderate-severity issue rather than a top-priority emergency.
Integer overflow in MPack 1.1.1's mpack_node_cstr_alloc() and mpack_node_utf8_cstr_alloc() helpers causes the allocation size computation (node.data->len + 1) to wrap to zero when a parsed MessagePack node advertises a length of SIZE_MAX, yielding an undersized buffer allocation and, in the officially scored path, a denial-of-service/crash. Exploitation requires the consuming application to use MPack's node/tree reader API and to call one of these helpers on a node whose length is attacker-controlled; it is realistically reachable on 32-bit platforms where SIZE_MAX equals UINT32_MAX (~4 GB) and generally infeasible on 64-bit platforms. The assessed vector is local (AV:L) with high attack complexity (AC:H) and no authentication or user interaction requirement (PR:N/UI:N), so remote reachability depends entirely on whether the host application exposes the parser to untrusted network input; there is no public exploit identified at time of analysis and EPSS is low at 0.20% (10th percentile).
Build-context directories belonging to IBM Concert 1.0.0 through 3.0.0 are recursively copied into produced container images, so any sensitive files sitting in that context (credentials, config files, keys, environment files) are baked into the image layers and disclosed to anyone who can pull the image or read its filesystem. The issue is local in nature (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, base 6.2): an attacker must already be able to obtain or access the built image, and no authentication or user interaction is involved, but the confidentiality impact on whatever was left in the build context is high, with no integrity or availability effect. There is no confirmed active exploitation (no CISA KEV listing) and no public exploit identified at time of analysis, so this is a genuine but low-urgency information-disclosure hygiene defect that matters most where images are pushed to shared or externally reachable registries.
Cross-site scripting in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift allows a remote, unauthenticated attacker to inject HTML/JavaScript that executes in the browser of a logged-in FTM operator, because HTML input is not properly neutralized (CWE-79). Exploitation requires the victim to load attacker-controlled content while holding an authenticated FTM session, so a successful attack is gated on user interaction and is confined to the victim's browser context rather than the FTM host itself. IBM has published a vendor advisory with fix guidance, no public exploit code and no confirmed active exploitation were identified at time of analysis, and EPSS data was not provided; the independent assessment rates this as CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, a lower integrity impact than the 8.2 base score supplied with the CVE, and the deployment is narrowed by FTM's specialized financial-transaction-processing footprint on OpenShift.
Reflected cross-site scripting in the WordPress Booking Calendar plugin (wpdevelop) affects every release up to and including 11.8.3, letting unauthenticated attackers craft a link that injects arbitrary JavaScript into a victim's browser within the target site's origin. Because the CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N (score 6.1, Medium), exploitation needs no credentials but does require a victim to click a malicious link, and the scope-change flag reflects that the injected script runs against the surrounding WordPress site rather than the plugin alone. No public exploit identified at time of analysis, and no CISA KEV listing or exploit code has been associated with this issue.
Reflected cross-site scripting in web.py 0.76 allows remote, unauthenticated attackers to inject and execute arbitrary JavaScript in a victim's browser session, because the framework's render_jinja.__init__() code path does not adequately constrain output escaping for user-controlled input that reaches Jinja-rendered templates. Exploitation requires the target application to actually route untrusted input into a render_jinja-generated response and requires victim interaction (UI:R) - the user must open an attacker-crafted link or supply attacker-influenced data - and the resulting impact is confined to the victim's browser within the site's origin (scope-changed, low confidentiality and integrity impact, no availability loss). No confirmed active exploitation (not in CISA KEV), no public exploit code identified at time of analysis, and EPSS is low at 0.19% (9th percentile), so real-world risk is governed primarily by whether a deployment passes untrusted data into Jinja-rendered output.
Opening a crafted ELF binary with radare2 or rabin2 before version 6.2.0 can drive a heap out-of-bounds read in the ELF parser and terminate the process, giving anyone who can supply the file to an analyst a local denial of service (CWE-125, CVSS 3.1 5.5, AV:L/AC:L/PR:N/UI:R, C:N/I:N/A:H). The trigger is a program-header count of 0xffff (ELF's PN_XNUM sentinel) paired with a small real count in shdr[0].sh_info: the parser allocates the program-header array using the resolved count while several consumers still iterate over the original 65535 value, reading past the allocation. Exploitation requires the user to open an untrusted binary, no public exploit code or confirmed in-the-wild activity has been reported, and memory disclosure or code execution has not been demonstrated, so the practical impact is a crash of the analysis process rather than a compromise.
radare2 versions prior to 6.2.0 can leak uninitialized or adjacent heap memory into JSON output, and may crash the process, when an analyst runs the explicit pFB or pFBj print command over an attacker-supplied binary property list. The root cause is an under-allocated, non-NUL-terminated UTF-8 conversion buffer in the binary-plist Unicode parser (CWE-125, out-of-bounds read) that the JSON encoder then scans as a C string. All signals agree this is a low-priority local issue: the CVSS vector is AV:L/PR:N/UI:R with only low confidentiality and low availability impact, there is no network vector, no privilege gain, and no write or code-execution primitive; no public exploit code has been identified at time of analysis and the issue is not in CISA KEV. Vendor-released fix: 6.2.0.
Stored cross-site scripting (CWE-79) in the LightRAG WebUI prior to 1.5.5 lets an attacker who can ingest a document persist raw HTML that the query path later returns and renders as active content, executing JavaScript in the WebUI origin for any user who views the poisoned answer. The vulnerable sinks are ChatMessage.tsx, which renders answer and thinking content through react-markdown with rehypeRaw and skipHtml=false but no HTML sanitizer, and a Mermaid rendering path configured with securityLevel 'loose' that injects generated SVG via innerHTML; an attacker-supplied iframe srcdoc or crafted mermaid block is sufficient to run script. Successful exploitation lets the attacker read the API token held in the victim's localStorage and perform API actions as that user, so the assessed scope is changed (S:C) with limited confidentiality and integrity impact. The assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N (6.1), meaning the attacker requires authenticated ingestion capability and the victim must run a query that surfaces the content and view it in the WebUI; no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV).
Authorization bypass in GitHub Enterprise Server allows any authenticated instance user to read the raw diff or patch of pull requests in private repositories they should not be able to access. The flaw (CWE-639) stems from raw diff/patch access tokens being scoped to a repository name and pull request number rather than a globally unique repository identifier, so an attacker who creates their own repository and pull request matching a target's name and number can reuse a token minted for their own repository to retrieve the private pull request contents. Exploitation requires a valid account on the instance, the ability to create repositories and pull requests, and knowledge of the target repository name and a valid PR number, which is why the vendor's CVSS 4.0 rating is 6.0 with AT:P and the impact is limited to confidentiality (no write or availability effect); no public exploit code has been identified at time of analysis and the issue is not in CISA KEV. All GHES versions prior to 3.22 are affected, with fixes in 3.17.21, 3.18.15, 3.19.12, 3.20.8, and 3.21.6.
Incorrect authorization in OpenBao releases prior to v2.6.0 lets an authenticated client bypass a more specific `capabilities = ["deny"]` rule when performing LIST or SCAN operations, exposing the names of secrets/metadata paths that policy explicitly marked as denied. The flaw only manifests in deployments that layer a trailing-wildcard deny (for example `secrets/metadata/restricted/*`) beneath a broader list/scan grant on a parent wildcard (for example `secrets/metadata/*`); read, write, delete and other operation types are unaffected, and only path/key names are disclosed, not secret values - consistent with the assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N. Vendor-released patch: v2.6.0. There is no public exploit identified at time of analysis and the issue is not in CISA KEV; overall this is a genuine but low-priority access-control flaw.
IBM Concert 1.0.0 through 3.0.0 uses weaker-than-expected cryptographic algorithms that can expose highly sensitive information to decryption by an attacker who obtains the protected data. The CVSS 3.1 vector is AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N, so no authentication or user interaction is required per the vector, but exploitation is constrained by high attack complexity and the need to acquire ciphertext before breaking the weak cryptography. No public exploit identified at time of analysis and no CISA KEV entry were provided; a vendor patch is available via IBM support node 7288830.
Malformed ZeroMQ AUX_DATA control messages can terminate the Decode worker's control thread in SGLang 0 through 0.5.15, letting an unauthenticated attacker who can reach the Decode control PULL socket take the inference server offline. The flaw is a missing input-validation check on the control-message path (availability-only impact; no data exposure or code execution), and the assessed CVSS 3.1 vector is AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H for a base score of 5.9. Exploitation is realistic only where the Decode control socket is exposed beyond localhost in disaggregated or multi-node deployments, which is why the attack complexity is rated High; no public exploit has been identified at time of analysis and the issue is not in CISA KEV.
Server-side request forgery in the Tauri HTTP plugin (tauri-plugin-http) before http-v2.7.0 lets any host the plugin's scope allowlist permits - a host the attacker controls or one hosting an open redirect - bounce the request onward to destinations the scope explicitly denies, including cloud metadata endpoints such as 169.254.169.254, localhost services, and internal network hosts. The plugin's reqwest client follows HTTP 3xx redirects internally and the scope allowlist was only evaluated against the frontend's original URL, so the redirect target is never re-checked; the response is then returned to the webview. Rated CVSS 5.6 (assessed AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:N/A:N), it is unauthenticated but requires an attacker-influenced allowlisted origin and a frontend that actually issues the fetch; there is confirmed actively exploited (CISA KEV) status, no public exploit identified at time of analysis, and the vendor fix is opt-in.
SQL injection in the login.php authentication handler of anirbandutta9's College-Notes-Gallery lets remote, unauthenticated attackers manipulate the 'user' and 'pass' request parameters to inject arbitrary SQL into the backend query, with low confidentiality, integrity, and availability impact per the assessed CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N). Exploitation requires only network reachability to a deployed instance exposing login.php, and publicly available exploit code exists (the disclosure was made public via the referenced GitHub issue and VulDB entries), though there is no confirmed active exploitation (CISA KEV) and EPSS data was not provided. Risk is tempered chiefly by deployment scarcity - this is an obscure open-source GitHub project with a very small install base - and by the fact that no vendor-released patch has been identified, since the vendor was contacted early but did not respond.
Opening a specially crafted file in Adobe Bridge triggers an out-of-bounds read that leaks potentially sensitive contents of the application's process memory. The flaw is local in nature - an attacker must first deliver a malicious asset and convince a victim to open it in Bridge (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N, base score 5.5) - so there is no remote or server-side exposure and no authentication requirement. Impact is limited to information disclosure (confidentiality high, integrity and availability unaffected); no public exploit code or confirmed active exploitation was identified at time of analysis, and Adobe has published advisory APSB26-148 covering the affected Bridge releases.
Server-side request forgery in Mattermost (11.7.x through 11.7.10, 11.8.x through 11.8.5, 11.9.x through 11.9.1, and 11.10.x through 11.10.1) allows an authenticated System Administrator to set the OAuth token or userinfo endpoint to an internal network address, causing the Mattermost server to issue that request because the platform's internal-connection filter is not applied to OAuth endpoint traffic, and then read the internal response back through the configured OAuth flow. Impact is bounded: the attacker must already hold the highly-trusted System Administrator role (CVSS PR:H), confidentiality and integrity effects are Low with no availability impact, and the flaw only matters where the Mattermost server has network reachability to sensitive internal services. There is no public exploit identified at time of analysis, no CISA KEV listing, and the vendor CVSS of 5.5 (Medium) is well-calibrated - this is a genuinely low-priority issue despite the CWE-918 classification. The assessment vector CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:L/I:L/A:N matches the vendor.
Unauthenticated SQL injection in Yonyou KSOA 9.0 lets remote attackers inject arbitrary SQL through the address parameter of the /cardcase/search_list.jsp endpoint, potentially reading or modifying database contents depending on the privileges of the database account the application uses. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms no credentials or user interaction are required, so any host able to reach the JSP page can attempt exploitation, and publicly available exploit code exists. There is no indication of confirmed active exploitation (not in CISA KEV), and although the vendor was contacted early about the disclosure it did not respond, so no vendor-released patch has been identified at time of analysis.
Integer overflow in Adobe's CAI Content Credentials Rust SDK and Content Credentials command-line tool crashes applications that parse a maliciously crafted C2PA/Content Credentials asset, producing a denial-of-service condition. The flaw requires no authentication (CVSS PR:N), but exploitation is gated by user interaction (UI:R) - a victim must visit a maliciously crafted URL or interact with a compromised web page that hands the crafted asset to a vulnerable parser - and the scored impact is limited to availability loss, with no code execution or data confidentiality impact. This is a genuine but low-priority issue: no public exploit identified at time of analysis, no confirmed active exploitation, and risk is confined to applications actually built on or invoking this SDK or CLI; maintainers of downstream consumers should follow Adobe advisory apsb26-147 for fixed builds.
Processing a maliciously crafted C2PA / Content Credentials asset through the CAI (Content Authenticity Initiative) Content Credentials Rust SDK or its companion command-line tool causes improper input validation (CWE-20) that terminates the application, resulting in an application-level denial of service. The flaw carries a CVSS 3.1 base score of 5.5 (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H), meaning exploitation is unauthenticated but requires the victim to actively load attacker-supplied input - for example by opening a malformed C2PA file, visiting a crafted URL, or interacting with a compromised web page that feeds the SDK. Per the independent assessment this is a genuine but low-priority issue: only a crash is achievable (no code execution, data disclosure, or integrity modification), and no public exploit code has been identified, with the issue not listed in CISA KEV. EPSS scoring was not provided in the available intelligence.
Opening a specially crafted document in Adobe InDesign Desktop drives the application into a NULL pointer dereference that terminates the process, giving an attacker a low-cost denial-of-service against a single user session. The attack is local in nature (CVSS AV:L) and requires the victim to manually open the malicious file (UI:R); per the CVSS vector PR:N, no authentication is needed, but the attacker must first deliver the file and socially engineer the user into opening it. Impact is confined to availability (C:N/I:N/A:H) - the user recovers by relaunching InDesign, possibly losing unsaved work - and there is no public exploit code or confirmed active exploitation identified at time of analysis, so this remains a genuinely low-priority issue despite its MEDIUM 5.5 rating.
Opening a specially crafted VRML/X3D or scene file with a GPAC-based application (GPAC 2d7da22e / 26.08-DEV) crashes the process through a NULL pointer dereference in the scene-graph cloning routine gf_sg_vrml_field_clone(), producing a denial of service. The trigger is a PROTO node whose default SFImage field has a NULL pixel source pointer, and per the assessed vector (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H) exploitation is local and requires the victim to open an attacker-supplied file, with impact limited to availability - no code execution, data disclosure, or privilege gain. Publicly available exploit code exists, but there is no evidence of active exploitation (not in CISA KEV) and the EPSS score is low at 0.20% (10th percentile), so this is a low-priority availability-only issue.
Loading a crafted .yrc compiled rules file crashes YARA 4.5.8 (libyara) by driving an internal assertion to abort, giving an attacker a denial-of-service primitive against any process that parses untrusted compiled rules. The malicious file declares num_buffers=0 in its arena header, which reaches yr_arena_get_ptr() in libyara/arena.c and trips a failed assertion, terminating the host application. Exploitation is local with user interaction (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H, score 5.5) and publicly available exploit code exists per the SSVC assessment (Exploitation: poc), though no confirmed active exploitation in CISA KEV has been reported and EPSS is low at 0.20% (10th percentile). Impact is limited to availability (process crash) with no confidentiality or integrity loss and no privilege escalation.
Heap memory corruption and denial of service in radare2 versions prior to 6.2.0 occur when the CPython .pyc marshal parser processes a crafted bytecode file that declares a string length of 0xffffffff, wrapping the size-plus-one allocation to zero before attacker-controlled data and fill bytes are written past the heap buffer. Exploitation is local and requires user interaction - an analyst must open or inspect the malicious .pyc with r2 or rabin2 - and no privileges are needed per the CVSS vector (AV:L/PR:N/UI:R), with impact confined to corrupting or crashing the analysis process. Arbitrary code execution is possible in principle but has not been demonstrated, no public exploit code has been identified at time of analysis, and the 5.5 CVSS score reflects a genuinely low-priority issue for most environments. Only workflows that routinely open untrusted .pyc files (malware analysis, CTF, reverse-engineering) are realistically at risk.
Denial of service in radare2 prior to 6.2.0 lets a crafted NE (New Executable) binary hang the tool indefinitely by driving the relocation fixup-chain parser into an unbounded loop that allocates a fresh relocation object on every pass, exhausting CPU and memory until the process is killed or the user aborts it. The attack is local and requires the victim to open the attacker-supplied file (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H), with availability impact only and no confidentiality or integrity effect, so this is a genuine but low-urgency issue. No public exploit code was identified at time of analysis and the flaw is fixed in version 6.2.0.
Denial of service in radare2 versions prior to 6.2.0 allows an attacker to exhaust memory and processing time in the analyst's session by supplying a small crafted full-memory Windows crash dump (dmp64 format), which the 64-bit dump parser opens without validating input-controlled page counts against the actual file size. Exploitation is local and requires user interaction - a victim must open the malicious dump (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H) - and the impact is confined to availability, with no code execution or data disclosure. No public exploit code and no confirmed active exploitation were identified at time of analysis.
Loading a crafted Apple Preferred Executable Format (PEF) file into radare2 prior to 6.2.0 can consume excessive CPU and stall or hang the analysis session, because the PEF loader accepts relocation-section counts that are not validated against the number of sections or the relocation records actually present in the input. The bug is reached through normal binary-format auto-detection, so simply opening or auto-analyzing the malformed file is sufficient; the attack is local and needs user interaction (CVSS:3.1/AV:L/AC:L/PR:N/UI:R) and results only in denial of service, with no confidentiality, integrity, or code-execution impact and no network-reachable attack surface. No public exploit code or confirmed active exploitation was identified at time of analysis, and the issue is fixed in radare2 6.2.0.