BeyondTrust Remote Support appliances contain an authentication bypass (CWE-290) in internal components that fail to validate the origin of received messages, potentially allowing an attacker to perform file operations on the appliance. According to the CVSS 4.0 vector (9.3), no authentication or user interaction is required, but the vendor notes exploitation is conditional ('under the right conditions') and the independent assessment emphasizes that an attacker must reach the internal messaging path and spoof a trusted source. No public exploit code or active exploitation has been identified at time of analysis, though this is a credible high-priority issue given the high impact.
Siemens Software Center (all versions) loads dynamic-link libraries from an uncontrolled search path, allowing an authenticated local attacker with high privileges to stage a crafted DLL where the application will load it and achieve arbitrary code execution in the application's context, with full confidentiality, integrity, and availability impact on the affected host. The vendor scores this CWE-427 DLL-hijacking issue CVSS 4.0 8.4 (AV:L/AC:L/AT:N/PR:H/UI:N), and our independent assessment agrees on the local vector, no user interaction, unchanged scope, and high C/I/A impact. There is no public exploit code identified at time of analysis and the flaw is not listed in CISA KEV; exploitation is constrained to a local, already highly privileged actor able to write to a directory on the loader's search path.
OS command injection in Netgate pfSense CE 2.7.0 through 2.9.0 allows an authenticated web-interface user who holds the QinQ edit privilege to execute arbitrary commands as root. The attacker saves a crafted parent interface ('if') value and then re-edits the QinQ entry, causing that unvalidated value to be interpolated into an ifconfig shell command; publicly available exploit code exists, and no confirmed active exploitation (CISA KEV) has been reported. The principal constraint is the high privilege requirement - only operators already trusted with interface configuration can reach the vulnerable code path - and risk is further reduced where the management UI is not exposed to untrusted networks or lower-privileged users.
OS command injection in Netgate pfSense CE 2.7.0 through 2.9.0 lets an authenticated web GUI user who holds the Traffic Shaper Limiters privilege execute arbitrary commands as root, turning a narrowly delegated configuration permission into full appliance compromise. The flaw is triggered when an operator edits a limiter and injects a crafted hidden 'number' value and then deletes that limiter, causing delete_queue() to pass the unquoted, attacker-controlled value to dnctl via /bin/sh running as root. Publicly available exploit code exists (VulnCheck advisory plus Abraxas Labs research and a PoC repository), and while the issue is not listed in CISA KEV as actively exploited, exploitation is gated on prior authenticated access with the Limiters privilege (PR:H) and on the attacker completing the limiter edit-then-delete workflow.
Command injection in Netgate pfSense CE through 2.9.0 allows an authenticated user with Virtual IP (CARP) edit privileges to execute commands as root by storing a malicious VHID value that is later interpolated into ifconfig calls or CARP status rendering. Publicly available exploit code exists, and the independent assessment rates this as a privilege-gated high-impact issue rather than an unauthenticated remote compromise; CISA KEV does not confirm active exploitation in the supplied data. Affected deployments are those where administrators or delegated operators can create or modify CARP VIPs, narrowing realistic risk to insiders or attackers who already hold privileged firewall UI access.
Command injection in Netgate pfSense CE through 2.9.0 allows remote authenticated users with limited 'Wireless Edit' or 'Interface Assignments' GUI privileges to execute arbitrary commands as root. The flaw is triggered by supplying a crafted wireless parent interface name such as ath0;<cmd> through interfaces_wireless_edit.php or interfaces_assign.php, which interface_wireless_clone() interpolates unescaped into an ifconfig shell command. Publicly available exploit code exists, and the assessed impact is high for confidentiality, integrity, and availability, though exploitation requires valid credentials with one of those specific privileges and access to the management interface.
OS command injection in Wavlink WL-WN530BE2-A firmware up to M30BE2_V250604 lets remote attackers reach the api.cgi login handler (api=info&client=app, function sub_12580) and inject shell metacharacters through the value the firmware treats as the client address (REMOTE_ADDR), potentially yielding arbitrary command execution with root-level privileges on the device. The vendor has confirmed the finding and shipped a fix in firmware 2026-09-24-841a51c6d5_tclinux.bin, which replaces the system() call with execvp and length-limits/null-checks the client address; publicly available exploit code exists (a GitHub PoC), though the weakness is not confirmed as actively exploited (CISA KEV). Exploitation is not as trivial as the raw CVSS 4.0 score of 9.3 implies: REMOTE_ADDR is conventionally derived from the TCP source address, so a real-world attacker likely needs the web server to trust a client-supplied address header or needs an on-path/proxy position, which materially narrows the population of reachable targets despite PR:N in the published vector.
Command injection in Netgate pfSense CE 2.4.5 through 2.9.0 lets an authenticated WebGUI user holding the Advanced Admin Access privilege execute arbitrary commands as root by placing newline or $(...) sequences in the Login Protection (sshguard) threshold, block time, or detection time fields, which are written unvalidated to sshguard.conf and sourced as root when the service restarts. The flaw is privilege-gated rather than mass-exploitable: the CVSS vector specifies PR:H, so only already-administrative accounts can trigger it, with no user interaction required beyond the attacker's own session. Publicly available exploit code exists (referenced in the CVE record), and the root cause is CWE-78 OS command injection.
OS command injection in Netgate pfSense CE (through 2.9.0) allows remote attackers holding an authenticated web-GUI account with gateway edit privileges to execute arbitrary commands as root by planting shell metacharacters in the zone index of an IPv6 link-local gateway Monitor IP, which start_dpinger() passes unescaped into the dpinger shell command when gateway monitoring is applied. Exploitation requires high privileges (CVSS 4.0 PR:H) and no victim interaction (UI:N), but yields high confidentiality, integrity and availability impact on the firewall itself; publicly available exploit code exists (abraxas/pfsense-gw-ipv6-zone) with no confirmed active exploitation reported. This is a genuine but access-gated priority: unauthenticated or low-privileged users cannot reach the vulnerable gateway-edit path, so exposure is limited to deployments where such configuration rights are delegated.
Command injection in pfSense CE 2.7.0 through 2.9.0 allows authenticated users who hold only the Captive Portal HA privilege to execute commands as root by manipulating backwardsyncip to point at an attacker-controlled XMLRPC server and returning connected_users entries with shell metacharacters in ip or mac fields. Exploitation is privilege-gated: it requires the specific Captive Portal HA WebGUI permission, use of Captive Portal high-availability sync, and the ability to influence the synced connected_users data. Publicly available exploit code exists, but no CISA KEV confirmed active exploitation is identified; this is a credible privilege-gated priority rather than a mass-exploitation emergency.
Unauthenticated attackers can register an administrator-equivalent account on any WordPress site running the User Rights Access Manager plugin through version 1.1.3, resulting in full site takeover. The plugin leaves one of its AJAX account-registration handlers accessible without any capability or nonce check, and assigns newly self-registered users a role that was created as a direct copy of the administrator role, so a single crafted request yields a fully privileged account. Publicly available exploit code exists, and the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) confirms the attack is remote, unauthenticated, and requires no user interaction; no CISA KEV entry has been reported, so active exploitation is not confirmed, but the low complexity and public proof-of-concept make this a high-priority patch target wherever the plugin is deployed.
Remote code execution in Jooan JA-A12 IP cameras running firmware 009_20171107 or 05.02.31.105 allows unauthenticated attackers to execute root-level commands by abusing hard-coded credentials. An attacker sends singleCMD=SetDiagMode to /goform/SingleHandlebyCommand with attacker-controlled authserverip and authcode values, causing the jooandiag daemon to run commands through /bin/sh and granting full device control. Publicly available exploit code exists, and the provided CVSS 4.0 score is 9.3; no CISA KEV listing is present in the supplied data.
Memory corruption in the Linux kernel IPv4 receive path lets a local attacker who can inject a packet with malformed checksum metadata (an out-of-range skb checksum_start) into the host IPv4 stack cause skb_checksum_help to write into and corrupt the network header, yielding high-integrity and high-confidentiality impact with a changed security scope (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H, 9.3). The flaw is realistically reachable by an unprivileged process inside a sandbox, container, or guest VM that can supply attacker-controlled checksum metadata to the host kernel, making multi-tenant and sandboxed environments the primary exposure; single-tenant systems with no untrusted local or sandboxed workloads are materially less exposed. Exploitation requires local access only (no remote network path indicated), and intelligence available at the time of analysis shows no confirmed active exploitation (no CISA KEV) - though linked references to sandbox-escape research (pwn.ai's 'Pwnescape' and Vercel's $1M sandbox challenge findings) indicate the underlying primitive is being actively studied.
A heap-based buffer overflow in the api.cgi management handler of Wavlink WN530HG4B routers (firmware M30HG4B_V260724) allows unauthenticated remote attackers to corrupt heap memory by sending a crafted request to the api=info&client=app endpoint. The vulnerability is rated 9.3 under CVSS 4.0 (assessed 9.8 under CVSS 3.1, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), reflecting no authentication requirement, no user interaction, and full loss of confidentiality, integrity, and availability on the affected device. Publicly available exploit code exists, and while the issue is not confirmed as actively exploited (not in CISA KEV), the weaponizable nature of an unbounded parameter flowing into a shell-invoked handler makes patching exposed devices a priority; the vendor has released firmware 2026-09-24-841a51c6d5_tclinux.bin that resolves the flaw.
PHP object deserialization in EspoCRM versions prior to 9.3.7 lets an authenticated administrator achieve remote code execution by storing crafted serialized object data in background MassAction or Export parameters that the application later unserializes without any allowed-class restriction. The deserialization sinks are reachable over the network (AV:N) with no user interaction (UI:N), and an attacker with admin credentials can instantiate arbitrary PHP objects and execute code, provided a usable gadget chain is reachable in the deployed codebase or its dependencies. Publicly available exploit code exists, and the vendor released a fix in version 9.3.7; the practical limiting factor is the administrator-privilege prerequisite (PR:H), which tempers real-world urgency even though the flaw is rated 9.1.
Authorization bypass in Netgate pfSense CE through 2.9.0 allows an authenticated WebGUI account that holds page privileges for services_acb.php, uploadconfig.php, diag_confbak.php, or diag_backup.php to replace config.xml despite lacking the 'User - Config: Deny Config Write' privilege; the account can otherwise be read-only. Successful exploitation can yield root-level code execution after a configuration reload or reboot, and publicly available exploit code exists. The independent assessment scores this CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (8.6), reflecting a remote authenticated low-privilege attacker with high confidentiality, integrity, and availability impact.
Unauthenticated denial of service in LightLLM through 1.2.0 lets any remote attacker who can reach the /generate endpoint take down the inference worker with a single crafted request: supplying the internal pd_kv_trans_params field causes a pickle.loads failure in InferSamplingParams that kills the inference thread. Because the /health endpoint keeps responding normally, monitoring will not detect the failure, and every subsequent request hangs until the process is restarted. Publicly available exploit code exists (referenced in the upstream GitHub issue), and no CISA KEV entry or EPSS data was provided; the assessed impact is availability-only with no confidentiality or integrity loss.
Unauthenticated remote denial of service in SODOLA SL902-SWTGW124AS switch firmware before version 200.2.12 lets any attacker who can reach the device's embedded HTTP management server crash it by sending a crafted multipart/form-data POST request containing an oversized boundary value in the Content-Type header. The overflow leaves the switch fully unresponsive, dropping both management access and traffic forwarding until its self-recovery cycle completes, though the assessment confirms no code execution, data disclosure, or configuration tampering occurs. Publicly available exploit code exists (published by the researcher and documented in the VulnCheck advisory), and the CVE carries a CVSS v4.0 base score of 8.7, but there is no indication of confirmed active exploitation in CISA KEV; the practical risk is governed mainly by whether the web management plane is exposed to attacker-reachable networks.
Authenticated VPN users can execute arbitrary commands as root on pfSense CE through 2.9.0 by exploiting an OS command injection in the OpenVPN connect/disconnect script, openvpn.connect_async.sh. The attack requires a valid VPN account authenticated via RADIUS or LDAP and a username containing single quotes and shell metacharacters that break out of an eval'd pfctl anchor name. Publicly available exploit code exists (reported by VulnCheck), though no active exploitation has been confirmed by CISA KEV. This is a credible high-priority issue for any pfSense CE deployment that uses OpenVPN with external authentication.
Command injection in Netgate pfSense CE 2.7.0 through 2.9.0 lets an authenticated administrator who holds IPsec Mobile configuration privileges store a crafted single-line login banner that escapes the unquoted strongswan.conf attr value and injects charon.start-scripts entries, resulting in command execution as root on the firewall. Exploitation is gated by high privilege (PR:H) and by a charon restart precondition - the injected payload only runs when the strongSwan daemon is restarted, not at submission time - but publicly available exploit code exists and the impact on confidentiality, integrity, and availability is high. This is a genuine high-priority issue for organizations running affected pfSense CE firewalls, but its exploitation is gated by privilege rather than exposure, and no unauthenticated or unprivileged path has been identified.
Root command execution on pfSense CE through 2.9.0 is achievable by authenticated attackers holding the 'WebCfg - Interfaces: PPPs: Edit' privilege, who inject newline characters into the ptpid or PPP periodic-reset hour/minute fields of interfaces_ppps_edit.php. The injected newlines are written unescaped into /etc/crontab by configure_cron(), causing scheduled root command execution. Publicly available exploit code exists; CISA KEV does not list this CVE, and no public exploit activity has been confirmed. CVSS 4.0 score is 8.6 (PR:H), and an independent assessment concurs with high impact but notes this is a credentialed privilege-escalation-to-root flaw rather than a pre-auth mass-exploitation threat.
Local file disclosure in SimplePie through 1.9.0 lets a malicious or compromised feed server read files on the host running the PHP application: by replying to a feed request with an HTTP Location redirect - or by planting an autodiscovery <link> - that points at a file:// path, the library follows the reference and reads the target file into the parsed feed. Exploitation requires no privileges (PR:N) but does require the attacker to control the feed server's responses or inject a feed URL into the application (AC:H, AT:P), and disclosure is bounded to files readable by the web-server process. Vendor fix is available via upstream PR 991, public exploit code exists (a PoC targeting pfSense's RSS widget has been published), and no confirmed active exploitation (CISA KEV) was identified at time of analysis.
Authenticated pfSense CE administrators with General Setup privileges can achieve root-level PHP code execution by injecting an auto_prepend_file directive into php.ini through an unvalidated timezone value. Publicly available exploit code exists, but exploitation is conditional: the injected directive only runs after php.ini is regenerated at boot or on a php-fpm restart, and the attacker already holds administrator-equivalent access, making this a post-authentication privilege escalation rather than an unauthenticated remote compromise or mass-exploitation threat. Netgate pfSense CE through 2.9.0 is affected.
Authenticated pfSense CE WebGUI users holding L2TP Server or PPPoE Server edit privileges can inject mpd5 commands - including an up-script that executes as root - by submitting a RADIUS shared secret that contains a quote and newline. The weakness affects pfSense CE through 2.9.0 and requires a RADIUS-backed VPN configuration that actually starts a session for execution; publicly available exploit code exists, but CISA KEV does not list this CVE and no confirmed active exploitation has been reported. This is a genuine but access-gated code execution issue rather than a mass-exploitation threat.
Command injection in pfSense CE through 2.9.0 allows authenticated users with the PPPoE Server Edit privilege to inject newline characters into the username field, causing mpd5 to run arbitrary commands as root when a PPPoE client authenticates. The flaw resides in services_pppoe_edit.php, which fails to sanitize the username POST field (CWE-93). Public exploit code exists, but exploitation requires an enabled PPPoE server and a subsequent client authentication event, limiting this to a post-authentication privilege-escalation attack.
Boolean-based blind SQL injection in EspoCRM versions 8.1.0 through 9.3.7 allows an authenticated non-administrator to inject crafted expressions through the 'where' parameter of the GET entity streamAttachments endpoint, enabling extraction of arbitrary database contents - including active administrator session tokens - and subsequent full privilege escalation. The flaw requires a valid low-privilege session (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L, 7.6) and is not exploitable anonymously. Public exploit code exists for this issue, though it has not been confirmed as actively exploited (CISA KEV); EspoCRM 9.3.8 is the fixed release.
Unauthenticated remote attackers can force-publish, rewrite, and create the managed pages of any WordPress site running Tutor LMS below 4.1.1, because the plugin's page-regeneration routine omits a capability check (CWE-862). Impact is confined to integrity - unpublished pages can be pushed live, existing page content overwritten, missing pages created, and the plugin options that reference those pages changed - with no confidentiality or availability effect and no code execution, so realistic damage is content tampering and manipulation of plugin page references rather than site takeover. Publicly available exploit code exists, and the CVSS 3.1 base score is 7.5 (HIGH) with vector AV:N/AC:L/PR:N/UI:N, making it trivially reachable on exposed sites; there is no CISA KEV entry indicating confirmed active exploitation at time of analysis.
Reflected cross-site scripting in the Document Gallery WordPress plugin (versions through 5.1.1) lets an unauthenticated attacker inject script into an HTML attribute returned by one of the plugin's AJAX actions, and the payload executes in the browser of any user who opens the crafted link - including a logged-in administrator. Publicly available exploit code exists and the issue is documented in the WPScan vulnerability database (EUVD-2026-101853), so exploitation only requires luring a victim into clicking or loading a malicious URL; no credentials are needed to deliver the payload (CVSS vector AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:L). At CVSS 7.1 the assessed impact is moderate rather than critical: script execution is confined to the victim's browser session instead of granting direct server control, there is no CISA KEV entry indicating confirmed actively exploited, and the decisive limiting factor is the mandatory victim interaction.
Local file read in Netgate pfSense CE through 2.9.0 allows an authenticated user who holds the Dynamic DNS client privilege to cause root-readable files such as /conf/config.xml or /etc/master.passwd to be written into the system log. The attacker configures a custom DynDNS provider with a file:// Update URL and a deliberately non-matching Result Match value, so the _checkStatus() routine logs the fetched content as root. Publicly available exploit code exists, but exploitation is privilege-gated: it requires access to services_dyndns_edit.php with the Dynamic DNS client privilege, and independent assessment confirms only confidentiality impact with no integrity or availability effect, making this a credible but limited information-disclosure risk rather than a mass-exploitation threat.
Heap out-of-bounds write in SoX (the sox CLI and any application linking libsox) through 14.4.2 allows a crafted MS ADPCM WAV file with an odd samplesPerBlock value in its fmt chunk to write a partially controlled 16-bit sample past the heap buffer allocated by wav_ms_adpcm_fmt(), corrupting adjacent memory. Triggering the flaw requires the victim to open or submit the malicious file to sox/libsox (local attack vector, user interaction), but no authentication or privileges are needed; publicly available exploit code exists and no CISA KEV listing is present. The assessed impact is low integrity and high availability (CVSS 3.1 6.9, CWE-787), with exposure concentrated in automated audio-processing services that decode untrusted files.
Out-of-bounds write in libTiMidity through 0.2.8 allows unauthenticated local attackers to corrupt heap memory and crash applications by loading a crafted SoundFont (.sf2) file whose preset header 'bank' or 'preset' values index past the fixed 128-entry tonebank or drumset arrays in init_soundfont(). The vendor CVSS 4.0 base score is 6.9 (moderate), reflecting high availability impact (crash) and low integrity impact, with exploitation requiring passive user interaction to open the malicious file. Publicly available exploit code exists, increasing the likelihood of targeted attacks against applications that process untrusted SoundFonts.
Stack out-of-bounds write in libTiMidity through 0.2.8 occurs when the SoundFont loader parses crafted .sf2 files, allowing an unauthenticated local attacker to corrupt stack memory via out-of-range pgen/igen generator operators in parse_gen, which writes chosen 16-bit values near the stack Layer object. This leads primarily to denial of service (crash) with a constrained memory corruption primitive; exploitation requires the victim to load a malicious SoundFont file (user interaction), and publicly available exploit code exists but there is no confirmed active exploitation. The assessed severity is moderate (CVSS 3.1 base score 6.1), consistent with a file-parsing memory-safety bug rather than a top-priority threat.
Heap out-of-bounds write in OpenJPH 0.32.0 and earlier allows memory corruption when the library decodes a crafted JPEG 2000 codestream (.j2c or .jph) that uses small precinct sizes to create degenerate one-row codeblocks; the HTJ2K cleanup-pass decoder then writes a second row beyond the end of the codeblock buffer, causing heap corruption and crashes. Publicly available exploit code exists, including a detailed technical write-up, but there is no indication of confirmed active exploitation (no CISA KEV listing), and the assessed attack vector is local with user interaction (CVSS 3.1 AV:L/AC:L/PR:N/UI:R, integrity impact low, availability impact high). Realistic exposure requires OpenJPH to sit in a decode path that accepts untrusted images, such as an upload handler, image viewer, or batch conversion service, where a victim is induced to open the malicious file.
Out-of-bounds write in libsmi through 0.5.0 allows attackers to corrupt adjacent library globals via a crafted MIB file that supplies an OCTET STRING DEFVAL of 512 or more octets beginning with a 0x00 byte, causing smiValueAsString() to overflow a fixed 1024-byte static buffer during hex rendering and crash smidump or other consumers. Exploitation requires the victim to load the malicious MIB (UI:P per CVSS 4.0; UI:R per independent CVSS 3.1 assessment) and is limited to local memory corruption with high availability impact and low integrity impact. Publicly available exploit code exists.
Heap out-of-bounds read in libewf through 20260924 allows an attacker to crash an application or leak uninitialized heap memory by supplying a crafted .L01/.Lx01 logical-evidence image containing oversized 'ea' (extended attribute) metadata counts. The flaw is reachable only when the tool actually parses the attacker-controlled image: the CVSS 4.0 vector is local (AV:L) with passive user interaction (UI:P) and no privileges required (PR:N), and impact is concentrated in availability (VA:H, a crash) with only limited confidentiality (VC:L, memory disclosure). Public exploit code exists, but the vulnerability is not confirmed as actively exploited in CISA KEV.
Heap out-of-bounds reads in the SoundFont loader (src/sndfont.c) of libTiMidity 0.2.8 and earlier allow an attacker to disclose heap memory and crash an application whenever a crafted .sf2 SoundFont is loaded through mid_set_soundfont(). The attack is local and requires the victim to open or otherwise load the malicious SoundFont (UI:P with AV:L), so the impact is bounded to low-confidentiality memory disclosure and a high-availability crash, with no confirmed integrity loss or code execution; any product that never parses untrusted or third-party SoundFont files is effectively unaffected. Publicly available exploit code exists - a public writeup and the referenced upstream source lines demonstrate the unvalidated sampleId/generator indexing - but there is no evidence of active exploitation, and exploitation prerequisites make this a moderate-priority rather than a critical remote threat.
Decoding a crafted PICT image with FreeImage (danoli3 fork) through 3.19.23 can over-read up to 64 KiB of heap memory inside Unpack32Bits() in PluginPICT.cpp, leaking process memory into the decoded pixel output or crashing the host application. The flaw affects any application that links the danoli3 fork (or the corresponding FreeImage codebase) and attempts to decode an attacker-supplied PICT file; per the assessed vector (AV:L/PR:N/UI:R) the attack requires a victim to open or process the malicious file, with no network-facing or unauthenticated remote path. Publicly available exploit code exists, but there is no confirmed active exploitation (no CISA KEV entry), and the impact is bounded to information disclosure and denial of service rather than code execution.
Heap out-of-bounds read in libyal libesedb (through 20260704, all versions per the wildcard CPE) lets an attacker who supplies a crafted ESE/EDB database file to a libesedb consumer such as esedbexport cause the parsing process to crash or to disclose roughly 32 KiB of adjacent heap memory through libesedb_record_get_multi_value(). Publicly available exploit code exists, but there is no indication of confirmed active exploitation (not in CISA KEV), and the CVSS 4.0 vector (AV:L, UI:P) means the issue is not remotely reachable: an attacker must first place the malicious file on a target system and get a user or an automated job to parse it. Impact is bounded to denial of service and limited heap information disclosure - not code execution - so this is a genuine but moderate-priority issue for workflows that process untrusted ESE databases.
Heap out-of-bounds read in ytnef through 2.1.2 allows an attacker to crash the ytnefprint utility and incidentally leak small amounts of adjacent heap memory by supplying a crafted winmail.dat whose compressed RTF property decompresses to data without a trailing NUL terminator. The flaw sits in MAPIPrint() in lib/ytnef.c and is reachable unauthenticated, but exploitation requires that a victim or an automated workflow open the malicious file, since the attack surface is local file parsing rather than a network service. Publicly available exploit code exists (linked proof-of-concept write-up), and there is no confirmed active exploitation (not in CISA KEV); the dominant realistic outcome is denial of service via crash, with only incidental memory disclosure of limited value.
Heap out-of-bounds read in ytnef through 2.1.2 allows unauthenticated local attackers to crash the application and leak adjacent heap memory by supplying a crafted winmail.dat TNEF file with a malicious PT_BINARY MAPI property. Publicly available exploit code exists, though the vulnerability is not confirmed as actively exploited. The CVSS 4.0 score is 6.9 (moderate), and exploitation requires the caller to process the attachment (passive user interaction).
Heap out-of-bounds read in libregf (all snapshots through 20260526) allows an attacker who supplies a crafted legacy Windows registry hive (REGF format version 1.0/1.1) to make a value-data cell appear shorter than it actually is, so the library reads past the end of the cell and either leaks adjacent heap bytes or crashes the process. Exploitation is local and requires the victim or an automated pipeline to actively open the malicious hive; no privileges are required, but user interaction is needed, and the assessed impact is limited to confidentiality loss and denial of service, with no write primitive or code execution indicated. Publicly available exploit code exists in the form of a linked technical writeup, but there is no CISA KEV confirmation of active exploitation; downstream consumers such as regfexport and plaso/log2timeline are affected.
Heap-based out-of-bounds read in the HCOMPRESS tile decoder of CFITSIO through 4.7.0 lets unauthenticated attackers trigger memory reads beyond the compressed tile buffer by supplying a crafted FITS file whose compressed image declares ZCMPTYPE HCOMPRESS_1 with oversized tile geometry; the flaw sits in the input_nnybble logic of fits_hdecompress.c and is reached through fits_read_pix. Impact is limited heap disclosure plus high availability loss - malformed reads can crash the consuming application - while confidentiality and integrity are only lightly affected (C:L, I:N per the source CVSS 4.0 vector, and assessed CVSS:3.1 as AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H). Publicly available exploit code exists, so the practical barrier is low, but exploitation is file-based: a victim application must ingest and decompress the malicious FITS file, so the issue is a genuine but moderate-priority concern rather than a top-tier emergency.
Heap out-of-bounds read in EarthScope libmseed through 3.5.4 occurs when an application passes a truncated 40-to-47-byte miniSEED 2 record that still satisfies the MS2_ISVALIDHEADER check to msr3_parse() or ms3_detect(); the parser then reads the blockette-offset field beyond the end of the allocated buffer, over-reading up to 8 bytes and potentially crashing the process. Publicly available exploit code exists (a detailed write-up and the upstream fix are both linked from the CVE references), but CISA KEV does not list this issue, so there is no confirmation of active exploitation. Impact is limited to a denial of service (process crash) with no confidentiality or integrity effect; exploitation is local and requires passive user interaction, since a victim application or automated ingest pipeline must actually feed the malformed record to the parser - no authentication is required.
Opening a malicious NSF file through libgme's gme_open_data or gme_open_file entry points can crash the host application via a global out-of-bounds read in Classic_Emu::mute_voices_, as a chip_flags value such as 0x3F implies a voice count exceeding the fixed 16-entry voice-type table. This affects Game Music Emu (libgme) through version 0.6.5; the vulnerability is local (AV:L) and requires user interaction (UI:P) to load the crafted file, but requires no privileges (PR:N). Publicly available exploit code exists, and the CVSS 4.0 base score is 6.8, though no confirmed active exploitation (CISA KEV) has been observed. No vendor-released patch has been identified at time of analysis.
Heap out-of-bounds read in libgme (Game Music Emu) through 0.6.5 allows local attackers to crash applications that parse a crafted ZXAYEMUL (AY-format) file through gme_track_info or gme_start_track. The root cause is an integer underflow in the AY loader's track-table bounds check in gme/Ay_Emu.cpp; the assessed impact is denial of service (process crash) with no confirmed code execution or data disclosure, and exploitation requires that the victim opens or otherwise processes a malicious file. Publicly available exploit code exists, but there is no CISA KEV confirmation of active exploitation, and the assessed CVSS:3.1 vector is AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H.
Heap out-of-bounds read in the PCM data-block decompressor (DecompressDataBlk) of ValleyBell libvgm through commit a6eed945 allows a crafted .vgm file to crash the consuming application. A malicious file supplies a PCM data block of type 0x7F with an undersized compression table that is then indexed by wider compressed values, forcing an out-of-bounds heap read; the confirmed impact is a denial-of-service crash of whatever player, converter, or emulator embeds the library, with no code execution, privilege escalation, or confirmed data disclosure. Publicly available proof-of-concept exploit code exists, and the issue is being tracked by VulnCheck; no confirmed active exploitation (CISA KEV) has been reported. Exploitation is local and file-based (CVSS:3.1/AV:L/AC:L/PR:N/UI:R), so an attacker must convince a victim to open the malicious media file, and no public EPSS score was included in the available data.
Loading a crafted PSID/RSID SID tune file in applications built on libsidplayfp through 3.1.1 crashes the process through a heap out-of-bounds read. The library trusts the header's data offset without validating it against the real file size, so an attacker-supplied offset wraps the length calculation in SidTuneBase::resolveAddrs() and the code reads up to 64 KiB past the heap buffer. The confirmed impact is denial of service only - no code execution and no verified data exposure - and an attacker must get a victim to open or play the malicious tune, so this is a moderate, not high-priority, issue; publicly available exploit code exists (a HackMD write-up), but there is no confirmed active exploitation (not in CISA KEV).
Denial of service in libansilove 1.3.0 through 1.4.2 lets a crafted XBIN file crash any application that parses it: setting the 512-character font flag while leaving the custom-font flag unset leaves the internal high_font_data_xbin pointer NULL, and drawchar() then dereferences it and terminates the process. The flaw is reachable by unauthenticated remote attackers (CVSS PR:N) but is file-based and local in nature (AV:L) and only triggers when the target application actually processes the malformed file (UI:P), so impact is confined to availability - no code execution, data disclosure, or data modification. Publicly available exploit code exists (proof-of-concept write-up published), and the 6.8 CVSS 4.0 base score overstates real-world urgency: practical exposure depends entirely on whether an embedding application accepts untrusted XBIN input, and active exploitation is not confirmed.
An out-of-bounds read in libansilove through 1.4.2 lets a crafted compressed XBIN file, particularly one whose run-length data ends on a control byte such as 0x7F, drive the ansilove_xbin() loader past the end of its input buffer and crash the rendering application. Applications that link libansilove and render untrusted XBIN art are affected; the outcome assessed is denial of service via crash rather than code execution or disclosure of sensitive data. Publicly available exploit code exists in the form of a published proof-of-concept writeup, and exploitation requires a victim to open an attacker-supplied file, making this a local, user-interaction-dependent medium-severity issue rather than a remotely reachable emergency.
A heap out-of-bounds read in NetSurf libnsbmp through 0.1.7 can crash applications that call bmp_decode() when they process a crafted ICO file whose inner bitmap width is not a multiple of 8. Publicly available exploit code exists, and exploitation requires user interaction to open or process the malicious file. The flaw is a one-byte over-read (CWE-125) with no privileges required (PR:N) but a local attack vector; the impact is limited to a possible application crash, with no confirmed data disclosure or code execution.