Freebsd

Privilege escalation in FreeBSD's POSIX shared memory subsystem allows an unprivileged local user to gain root-level access by exploiting a race condition in the FIOSSHMLPGCNF ioctl handler. The kernel's largepage shared memory page-size configuration check is performed without holding the rangelock, enabling two concurrent callers to each observe an unconfigured object and write conflicting page sizes, corrupting kernel object state in an exploitable way. No public exploit code or CISA KEV entry has been identified at time of analysis; EPSS is 0.13% (3rd percentile), indicating low current exploitation probability, though local privilege escalation primitives in OS kernels are high-value targets for post-compromise and container-escape scenarios.

Privilege escalation in FreeBSD's tty subsystem allows a local unprivileged user to gain elevated privileges by exploiting a race condition in the TIOCSCTTY ioctl handler. The handler fails to revalidate terminal state after a lock-drop sequence, enabling a concurrently destroyed terminal to be incorrectly linked to the attacker's session. No public exploit code has been identified at time of analysis, but vendor-confirmed patches exist for all affected release lines (15.0-RELEASE, 15.1-RELEASE, and 14.4-RELEASE).

Buffer overflow in FreeBSD's ppp(8) PPP daemon enables a local user with access to the ppp(8) command interface to crash the process or execute arbitrary code as root by supplying an oversized PSN endpoint value to the mp_SetEnddisc() function, which copies the input without length validation. FreeBSD 15.1-RELEASE (before p3), 15.0-RELEASE (before p13), and 14.4-RELEASE (before p9) are all confirmed affected per EUVD-2026-66248 and FreeBSD Security Advisory SA-26:60. No public exploit has been identified at time of analysis, and the low EPSS score (0.27%, 19th percentile) indicates limited exploitation interest despite the High CVSS rating.

Out-of-bounds write in FreeBSD's userspace ppp(8) daemon allows a malicious PPP peer to crash the process or execute arbitrary code as root. The flaw is in LcpDecodeConfig(), which fails to validate endpoint discriminator option lengths against the RFC 1717 minimum, enabling memory corruption during LCP negotiation. Affected releases are FreeBSD 15.1-RELEASE prior to p3, 15.0-RELEASE prior to p13, and 14.4-RELEASE prior to p9; no active exploitation or public proof-of-concept has been identified at time of analysis.

Heap-based buffer overflow in FreeBSD's ppp(8) daemon allows a malicious PPP peer to crash the daemon or execute arbitrary code as root. The flaw resides in mp_Enddisc(), which miscalculates buffer lengths when formatting Multilink PPP endpoint discriminator addresses, overflowing a global result buffer. Affected releases are FreeBSD 14.4-RELEASE prior to p9, 15.0-RELEASE prior to p13, and 15.1-RELEASE prior to p3; no active exploitation is confirmed (not in CISA KEV), but SSVC rates the technical impact as total and the attack as automatable.

Memory updated with the new marker. The analysis is clean and unmanipulated.

Privilege escalation in FreeBSD's kernel audio subsystem allows an unprivileged local user on systems with multiple audio devices to exploit a use-after-free in the sync group ioctl locking path to achieve full kernel compromise. The race condition arises when the ioctl releases the sync group list lock to sleep during a blocking lock attempt, and a concurrent operation frees the sync group structure before the sleeping thread reawakens and dereferences it. Affected releases include FreeBSD 14.4-RELEASE prior to p9, 15.0-RELEASE prior to p13, and 15.1-RELEASE prior to p3; no active exploitation has been confirmed (not in CISA KEV) and EPSS sits at 0.16% (6th percentile), reflecting low current threat activity.

Privilege escalation in FreeBSD 15.x unix socket implementation allows an unprivileged local user to achieve full system compromise via a use-after-free in the SOCK_STREAM receive path. Control messages are not fully detached from the socket buffer before error-path code frees the associated mbufs, leaving dangling references exploitable by a low-privileged attacker. No public exploit has been identified at time of analysis, but the low attack complexity (AC:L) and confirmed patch availability from the FreeBSD project make this a clear and immediate patching priority for affected deployments.

Privilege boundary violation in FreeBSD's hwpmc(4) hardware performance monitoring subsystem allows a low-privileged local user to continue observing a process via attached PMCs after that process elevates privileges by executing a setuid or setgid binary, directly contrary to the kernel's intended security policy. Affected versions span FreeBSD 14.4-RELEASE before p9, 15.0-RELEASE before p13, and 15.1-RELEASE before p3; vendor patches are available per FreeBSD Security Advisory SA-26:56. No public exploit has been identified and EPSS sits at 0.15% (5th percentile), placing this as a low near-term exploitation priority despite the high vendor CVSS score.

FreeBSD's ELF core dump subsystem contains a TOCTOU race condition that allows an unprivileged local user sharing an address space via rfork(2) to trigger a kernel heap out-of-bounds write, potentially escalating privileges to root. Affected releases are FreeBSD 14.4-RELEASE prior to p8, 15.0-RELEASE prior to p12, and 15.1-RELEASE prior to p2, as confirmed in FreeBSD Security Advisory FreeBSD-SA-26:55.elf. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Out-of-bounds kernel heap read and write in FreeBSD's semctl(2) GETALL and SETALL commands enable local privilege escalation by exploiting a 15-bit sequence-number wraparound in the System V semaphore subsystem. FreeBSD 14.4-RELEASE prior to p8, 15.0-RELEASE prior to p12, and 15.1-RELEASE prior to p2 are affected. An unprivileged local attacker races two processes - one cycling semaphore set destruction and recreation to wrap the 0x8000-bounded counter, another issuing GETALL or SETALL at the moment of wrap - causing the kernel to copy semaphore values using a mismatched buffer size and producing exploitable heap corruption. No public exploit code has been identified at time of analysis, but the vulnerability class (local kernel heap OOB via IPC race) is a consistently weaponized primitive for privilege escalation.

Privilege management regression in FreeBSD 15.x ktrace(2) allows an unprivileged jail user to manipulate or suppress the jailed root user's kernel tracing configuration. Because an unrelated code change inadvertently causes PRIV_KTRACE to always be denied to jailed root, that user's active trace sessions are not marked as privileged - permitting any jail user holding debug rights over a traced process to alter or clear those trace flags. No public exploit has been identified and the EPSS score of 0.18% (8th percentile) reflects negligible opportunistic exploitation probability, though multi-tenant jail environments relying on ktrace for security auditing face a meaningful auditability risk.

FreeBSD's wg(4) WireGuard kernel driver silently accepts packets bearing invalid Poly1305 authentication tags, completely defeating WireGuard's cryptographic integrity guarantee on affected FreeBSD versions. The driver dispatches decrypt operations to the OpenCrypto Framework (OCF) but never checks the returned MAC verification result, meaning tampered or forged ciphertext passes through as legitimate plaintext. Two distinct attack paths exist: an on-path attacker who can intercept WireGuard UDP traffic can modify ciphertext and authenticated data without detection, while a remote attacker with knowledge of the receiver's replay window bounds can inject forged transport data packets directly. No public exploit has been identified and EPSS sits at 0.18% (8th percentile), indicating no widespread automated exploitation at time of analysis.

Kernel stack memory disclosure in FreeBSD 15.x exposes uninitialized data to unprivileged local users through a missing error-return check in the POSIX timer subsystem. When a CLOCK_TAI timer is created on a system lacking a configured UTC-TAI offset, the kernel function realtimer_gettime() fails silently, and the resulting uninitialized stack buffer is copied verbatim to userspace via timer_settime(2). Affected releases are FreeBSD 15.0-RELEASE prior to p12 and 15.1-RELEASE prior to p2; no public exploit or CISA KEV listing has been identified at time of analysis.

Use-after-free in the FreeBSD 15.1-RELEASE kernel's kqueue subsystem allows an unprivileged local user to corrupt kernel memory and escalate privileges to root. During a fork() system call, the kernel's knote copy routine fails to hold appropriate locks while reading knote state, and does not guard against a timer-based knote firing and being enqueued on the active list mid-copy, resulting in a double-enqueue of the new knote and subsequent list corruption. No public exploit or active exploitation has been identified at time of analysis, but the CVSS score of 8.4 (Local/No Privileges Required) reflects a realistic, high-severity local privilege escalation path on affected systems.

Stack buffer overflow in the FreeBSD iconv(3) ISO-2022 encoding modules allows a 4-byte out-of-bounds write when converting untrusted text to or from certain ISO-2022 variants. The affected code sizes an intermediate output buffer to MB_LEN_MAX (6 bytes), but some ISO-2022 variants emit up to 10 bytes per character, overflowing the stack. It affects FreeBSD 14.3, 14.4, 15.0, and 15.1 release branches before the fixed patch levels; there is no public exploit identified at time of analysis, it is not in CISA KEV, and EPSS is low (0.21%).

Heap buffer overflows in FreeBSD's iconv(3) character-conversion library allow attackers who control input processed through the HZ, UTF-7, VIQR, or ZW encoding modules to corrupt heap memory, potentially leading to remote code execution. Applications on FreeBSD 14.3/14.4/15.0/15.1 that pass untrusted data through iconv using any of these encodings are exposed. No public exploit identified at time of analysis, and EPSS exploitation probability is low (0.21%, 12th percentile) despite the 9.8 CVSS.

Uninitialized kernel stack memory disclosure in FreeBSD's compat32 kevent() handler allows local unprivileged users to read small amounts of sensitive kernel stack data. Affected releases span FreeBSD 15.0-RELEASE before p11, 14.4-RELEASE before p7, and 14.3-RELEASE before p16, covering systems where 32-bit application compatibility is enabled. EPSS sits at 0.15% (5th percentile), no public exploit code is known, and the vulnerability is not listed in CISA KEV, indicating low exploitation urgency despite the CVSS C:H rating.

Kernel stack data disclosure in FreeBSD's Linux compatibility layer (linuxulator) allows any unprivileged local user to read up to 104 bytes of uninitialized kernel stack memory per `waitid()` invocation. The root cause is a missing zero-initialization of the destination `siginfo_t` buffer during FreeBSD-to-Linux struct translation, exposing residual kernel stack contents such as pointers and potentially cryptographic material. Patch levels are confirmed by vendor advisory FreeBSD-SA-26:47.linux; no active exploitation is confirmed in CISA KEV, and the EPSS score of 0.15% places this in the 5th percentile for near-term exploitation probability.

Kernel panic in FreeBSD's kernel TLS (kTLS) subsystem, specifically in ktls_ocf_tls_cbc_decrypt(), allows a remote TLS 1.2 peer to crash the kernel by exploiting an uninitialized iovec array bug during CBC record decryption. Affected versions span FreeBSD 14.3, 14.4, 15.0, and 15.1 prior to their respective patch levels, as confirmed by FreeBSD Security Advisory FreeBSD-SA-26:46.ktls. No public exploit code exists and EPSS is negligible at 0.15%, but the attack requires only that the remote peer engineer specific TCP segmentation - a condition achievable by the peer itself without any elevated privilege on the target system.

Privilege escalation in FreeBSD's RACK TCP stack via a use-after-free condition allows an unprivileged local user to achieve full system compromise. The RACK setsockopt(2) handler temporarily releases the connection lock while copying option data from userspace; if a concurrent context switches TCP stacks twice during this window, the stale saved pointer to the per-connection control block references freed memory while the integrity check erroneously passes. Affected versions span FreeBSD 14.3, 14.4, 15.0, and 15.1 release branches, with vendor patches confirmed via FreeBSD-SA-26:43.tcp; no public exploit has been identified at time of analysis.

Path containment bypass in FreeBSD's unlinkat(2) and funlinkat(2) syscalls allows a local low-privileged process to delete files outside its intended directory scope. The kernel validates AT_RESOLVE_BENEATH but silently discards it before handing off to the path resolution layer, making the flag a no-op security guarantee. Applications using this flag as a sandbox boundary for file deletion operations are exposed to unintended tree traversal, with impact on both filesystem integrity and availability. No public exploit code and no CISA KEV listing have been identified; EPSS is 0.13% (3rd percentile), indicating low observed exploitation probability.

Stack-based buffer overflow in FreeBSD's libalias RTSP handler exposes NAT gateways to kernel-level or root-level remote code execution from hosts inside the NAT perimeter. The RTSP protocol rewriter copies rewritten packet data into a fixed-size stack buffer with no length validation, allowing a crafted RTSP stream to overflow that buffer. When NAT is implemented via ipfw(4), exploitation can yield kernel code execution; when using natd(8), the impact is RCE in a process typically running as root. No public exploit code has been identified at time of analysis, and the CVE is not listed in CISA KEV.

Incorrect authorization in FreeBSD's ZFS_IOC_SET_PROP ioctl allows any local unprivileged user to set the internal '$hasrecvd' metadata flag on ZFS datasets - a capability that should be restricted to privileged ZFS receive operations. Affected release lines span FreeBSD 14.3, 14.4, 15.0, and 15.1 prior to their respective patch levels, as confirmed by FreeBSD Security Advisory FreeBSD-SA-26:40.zfs. No public exploit code exists and EPSS probability is 0.18% (8th percentile), indicating very low real-world exploitation pressure; no confirmed active exploitation or CISA KEV listing applies.

Kernel memory corruption in FreeBSD's ZFS subsystem allows a local user with the delegated 'receive' ZFS permission to trigger a heap-based buffer overflow via the ZFS_IOC_RECV_NEW ioctl. The flaw stems from an integer truncation: a 64-bit payload size is silently narrowed to 32 bits for heap allocation, but the original 64-bit value is then used as the length for a subsequent byteswap operation - writing beyond the allocated buffer into kernel memory. Exploitation is limited to the heal receive path and requires the ZFS 'receive' delegation, but no patch has been publicly released yet for all affected branches. No public exploit code or CISA KEV listing has been identified at time of analysis.

Kernel heap overflow in FreeBSD's ZFS subsystem via the ZFS_IOC_USERSPACE_MANY ioctl enables local privilege escalation across multiple supported FreeBSD release branches. The flaw stems from an integer width mismatch: the kernel allocates a heap buffer sized by a 32-bit truncation of the caller-supplied 64-bit length, then copies records up to the original 64-bit limit - writing past the end of the allocation. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog; however, the low attack complexity and high impact across confidentiality, integrity, and availability make patching a priority for any FreeBSD deployment that uses ZFS delegated permissions.

Local privilege escalation in FreeBSD's execve(2) syscall allows an unprivileged local user to gain full root-level control by exploiting a TOCTOU race condition (CWE-367) in SUID binary execution. During the narrow window between virtual address space installation and credential elevation, the kernel's procfs permission check still evaluates the original (unprivileged) credentials, allowing a racing process to write to the target's memory via /proc/[pid]/mem or linprocfs. Confirmed affected versions span FreeBSD 14.3, 14.4, 15.0, and 15.1; EPSS is low at 0.12% (2nd percentile), no KEV listing, and no public exploit identified at time of analysis, though the primitives for this class of attack are well-understood.

Reference count underflow in FreeBSD's jail subsystem allows an unprivileged local user to double-free a prison structure, yielding two distinct impact paths: on the jail host, this reliably causes an immediate kernel panic, while a user already running inside a jail may be able to exploit the freed structure while still in use to escape the jail and elevate privileges to the host. Affected releases are FreeBSD 15.0-RELEASE before patch level 11 and FreeBSD 15.1-RELEASE before patch level 1, per FreeBSD Security Advisory SA-26:38. EPSS is currently 0.16% (5th percentile) and SSVC classifies exploitation as 'none', suggesting no observed in-the-wild activity, but SSVC technical impact is rated 'total', reflecting the severity of the jail-escape scenario.

Use-after-free in the FreeBSD kernel virtual memory subsystem allows an unprivileged local user to corrupt the pager's page list by calling msync(MS_INVALIDATE) on a mapping of an unmanaged device object, then triggering a subsequent page fault. On object destruction, the affected page is freed twice, creating a kernel memory corruption primitive that may enable privilege escalation. No public exploit code has been identified and EPSS probability is very low (0.14%), but the vulnerability is confirmed by FreeBSD Security Advisory SA-26:37 with patches available for all affected release branches.

Local privilege escalation in the FreeBSD kernel's vt(4) console driver stems from an integer overflow in the CONS_HISTORY ioctl handler, where an unvalidated history-size value undersizes a heap allocation and a subsequent buffer initialization writes past its end. Any unprivileged local user with access to a vt(4) terminal device can corrupt kernel heap memory and potentially escalate to root. Exploitation is local (PR:L) with no public exploit identified at time of analysis and a low EPSS of 0.18% (8th percentile).

Local ASLR bypass in the FreeBSD ELF image activator (kernel) lets an unprivileged user neutralize address-space layout randomization for setuid PIE binaries. By calling procctl(2) to request ASLR disablement before execve(2), the per-process disable flag remains active when the PIE base address is computed, because the activator clears the flag too late. This is a mitigation-weakening flaw that materially eases exploitation of any separate memory-corruption bug in those privileged binaries; there is no public exploit identified at time of analysis and EPSS is low (0.18%, 8th percentile).

Local privilege escalation in FreeBSD's Linux binary compatibility layer (Linuxulator) allows an unprivileged user to preload a malicious shared library into set-user-ID or set-group-ID Linux binaries. Because the P_SUGID flag is not yet set when execve(2) builds the auxiliary vector, AT_SECURE is written as zero, so the Linux runtime loader fails to disable LD_PRELOAD and other unsafe behaviors for privileged binaries. Affects FreeBSD 14.3, 14.4, and 15.0 release branches; no public exploit identified at time of analysis, and EPSS risk is low (0.14%, 4th percentile).

Local privilege escalation in the FreeBSD kernel arises from a use-after-free in the IPv6 multicast source-filter handler (IPV6_MSFILTER), affecting FreeBSD 14.3, 14.4, and 15.0 releases before their respective patch levels. An unprivileged local user can win a race against the handler's dropped-then-reacquired serializing lock to free the multicast filter structure out from under the kernel, corrupting memory to gain root-level control. There is no public exploit identified at time of analysis, and EPSS is very low (0.13%), consistent with CISA SSVC marking exploitation as 'none' and not automatable.

Capsicum sandbox escape in FreeBSD allows a compromised capability-mode process to send arbitrary signals - including SIGKILL and SIGSTOP - to processes outside its sandbox, undermining Capsicum's core isolation guarantee. Affected are FreeBSD 14.3-RELEASE through 15.0-RELEASE in versions prior to their respective patch levels; the root cause is a 2011-era omission in kern_sigqueue that never enforced a PID self-restriction when a process operates in capability mode. EPSS is 0.14% (4th percentile), SSVC marks exploitation as none and non-automatable, and no public exploit has been identified at time of analysis.

Local privilege escalation in the FreeBSD kernel sound subsystem lets an unprivileged user map kernel memory outside the audio buffer via an integer-overflow flaw in dsp_mmap_single(). Because /dev/dsp device nodes are world-accessible by default, any local user on a system with an audio device can read and write arbitrary kernel memory, enabling full system compromise or a kernel panic (DoS). No public exploit identified at time of analysis; EPSS is low (0.19%, 9th percentile), and FreeBSD has released errata patches.

Local privilege escalation in FreeBSD 14.3, 14.4, and 15.0 releases arises from a use-after-free in the sound (OSS) subsystem, where an audio buffer backing a memory mapping is freed on device close while the mapping stays valid, leaving a stale mapping into reusable kernel memory. Because /dev/dsp device nodes are world-accessible by default, any unprivileged local user on a system with an audio device can read and write kernel memory to escalate to full control, or at minimum crash the kernel for denial of service. There is no public exploit identified at time of analysis, KEV shows no active exploitation, and EPSS is low at 0.19%.

Signal delivery bypass in FreeBSD's thr_kill2(2) system call allows an unprivileged local user - or a jailed process - to send arbitrary signals to any process on the system, including root-owned processes and critical daemons, causing Denial of Service. The flaw stems from a missing check on the return value of p_cansignal(), the kernel's permission enforcement primitive: the signal is unconditionally delivered before the error is propagated to the caller. No public exploit has been identified at time of analysis and SSVC assesses exploitation as none, though globally sequential thread IDs reduce the skill requirement to simple brute force, and the jail boundary bypass adds a container-escape dimension absent from the base CVSS score.

Page-cache corruption in FreeBSD's kTLS-RX subsystem (CVE-2026-45257 / FreeBSD-SA-26:26.kTLS) enables an unprivileged local user to overwrite arbitrary bytes in the backing physical page of any world-readable file, including SUID-root binaries, by exploiting in-place AES-GCM decryption running directly over sendfile(2)-produced EXTPG mbufs via the kernel direct map (DMAP). The write bypasses the VFS layer entirely, defeating file permissions, mount options, and chflags schg immutable flags - making this the FreeBSD functional equivalent of Linux CVE-2022-0847 (Dirty Pipe). A public exploit (bumsrakete.c) is included in the oss-security disclosure and achieves reliable root LPE in approximately 1.5 seconds on default FreeBSD 13.0 through 15.0 on amd64, arm64, and riscv; no public KEV listing has been identified at time of analysis.

cap_net privilege escalation in FreeBSD allows Capsicum-sandboxed applications to silently expand their own network operation permissions beyond what was explicitly granted. When a sandboxed process submits a new cap_net limit that omits a key present in the previously active limit, the service incorrectly treats the omission as an unrestricted allow-any grant rather than rejecting the request. Affected releases are FreeBSD 15.0-RELEASE before patch 9, 14.3-RELEASE before patch 14, and 14.4-RELEASE before patch 5; no public exploit is identified and EPSS sits at 0.01% (3rd percentile), though SSVC flags the attack as automatable once the preconditions are met.

Command injection in FreeBSD's bsdinstall(8) and bsdconfig(8) utilities allows an adjacent attacker to execute arbitrary code as root by broadcasting a Wi-Fi access point with a maliciously crafted SSID. The vulnerable shell script builds a network-selection menu without quoting network names, so a shell metacharacter-laden SSID is expanded and executed the moment an operator triggers a Wi-Fi scan - no need to select the rogue network. There is no public exploit identified at time of analysis, and the EPSS score is very low (0.03%), consistent with the CISA SSVC assessment of no observed exploitation.

Local privilege escalation in FreeBSD's libcasper(3) library affects FreeBSD 14.3, 14.4, and 15.0 releases prior to specified patch levels, where a missing FD_SETSIZE bounds check enables stack corruption when a low-privileged attacker forces a setuid-root application to allocate file descriptors above 1024. Successful exploitation yields root-equivalent privileges on the local host. No public exploit identified at time of analysis and EPSS scores exploitation probability at just 0.02%, but the issue is confirmed by a FreeBSD security advisory (SA-26:22.libcasper).

Local privilege escalation in FreeBSD via the ptrace(PT_SC_REMOTE) interface allows an unprivileged user with debug access to a process to trigger arbitrary kernel code execution by abusing improperly validated parameters in syscall(2) and __syscall(2) meta-system calls. Affected releases include FreeBSD 14.3, 14.4, and 15.0 prior to their respective patch levels, and no public exploit identified at time of analysis. EPSS exploitation probability is low (0.02%) but the CVSS base score of 8.4 reflects high impact across confidentiality, integrity, and availability once a foothold exists.

FreeBSD's fusefs kernel module mishandles extended attribute list responses from FUSE userspace daemons by calling strlen() on daemon-supplied buffers without first verifying NUL-termination, enabling a malicious daemon operator to read up to 253 bytes of kernel heap memory or inject up to 250 attacker-controlled bytes into unallocated kernel heap space. Affected releases are FreeBSD 14.3-RELEASE prior to p14, 14.4-RELEASE prior to p5, and 15.0-RELEASE prior to p9 per FreeBSD-SA-26:20.fusefs and EUVD-2026-31254. No public exploit code exists and EPSS sits at 0.02% (5th percentile), though the heap write primitive carries local privilege escalation potential beyond what the CVSS integrity score reflects.

Local privilege escalation in the FreeBSD kernel (14.3, 14.4, and 15.0 release branches) lets an unprivileged local user obtain superuser privileges through a use-after-free in the poll(2)/select(2) subsystem. When a file descriptor is closed while a thread is still blocked waiting on it, certain descriptor types fail to unlink the sleeping thread from the object's wait queue before the object is freed, so the later wakeup dereferences freed kernel memory. No public exploit identified at time of analysis, and CISA SSVC records exploitation status as none, but technical impact is rated total.

Local privilege escalation in the FreeBSD kernel's setcred(2) system call lets an unprivileged local user overflow a fixed-size kernel stack buffer and potentially execute arbitrary code with kernel privileges. The flaw affects the FreeBSD 14.3, 14.4 and 15.0 release lines and stems from the length of the caller-supplied supplementary groups list being validated only after it has already been copied into the buffer. There is no public exploit identified at time of analysis, the EPSS probability is very low (0.02%), and CISA SSVC records no known exploitation, but the technical impact is rated total.

Heap buffer overflow in FreeBSD's libnv library allows remote unauthenticated attackers to achieve privilege escalation or denial of service through maliciously crafted message headers. The vulnerability affects FreeBSD versions 13.5, 14.3, 14.4, and 15.0, with patches released in security advisory FreeBSD-SA-26:17.libnv. Despite network attack vector and privilege escalation potential (CVSS 8.1), EPSS scoring indicates only 0.02% exploitation probability (5th percentile), and no active exploitation or public exploit code has been identified. SSVC classifies technical impact as partial with no confirmed exploitation.

Stack corruption in FreeBSD libnv library allows local authenticated attackers to elevate privileges to root when exploiting setuid-root applications. The vulnerability stems from libnv's select(2) implementation failing to validate socket descriptors against FD_SETSIZE limits (1024), enabling descriptor exhaustion attacks that corrupt stack memory. Confirmed by FreeBSD Security Advisory SA-26:16 with patches available across all stable branches. EPSS score of 0.02% indicates low observed exploitation probability, and no active exploitation or public POC identified at time of analysis.

Heap buffer overflow in FreeBSD dhclient enables potential remote code execution when processing maliciously crafted DHCP packets. Affects FreeBSD 13.5, 14.3, 14.4, and 15.0 branches prior to security patches. EPSS exploitation probability is low (0.03%, 8th percentile) and no active exploitation confirmed, but SSVC classifies this as automatable with partial technical impact. The vulnerability requires network position to send crafted DHCP responses (CVSS AV:N/AC:H), making exploitation complexity high but not requiring authentication.

Remote denial-of-service in FreeBSD packet filter (pf) allows unauthenticated attackers to crash systems via malformed SCTP packets. Unbounded recursion in SCTP chunk parameter parsing triggers stack overflow, causing kernel panic on any FreeBSD system with pf enabled, regardless of firewall ruleset configuration. EPSS score of 0.06% (17th percentile) suggests low broad exploitation probability, but impact is critical for exposed FreeBSD firewalls. Official patch released by FreeBSD covering versions 13.5, 14.3, 14.4, and 15.0.

Local privilege escalation in FreeBSD kernel allows authenticated users to gain root privileges through buffer overflow in execve(2) argument handling. The vulnerability stems from an operator precedence bug causing attacker-controlled data to overwrite adjacent execution argument buffers. CISA SSVC framework indicates no active exploitation detected, though the technical impact enables complete system compromise. EPSS probability remains very low (0.02%, 5th percentile), suggesting targeted rather than widespread threat. FreeBSD has released patches across all supported release branches.

Remote code execution as root in FreeBSD dhclient allows malicious DHCP servers to inject arbitrary commands via unsanitized BOOTP file field in DHCP responses. When dhclient writes lease data without escaping embedded double-quotes and later re-parses it (e.g., after system restart), injected dhclient.conf directives execute through dhclient-script. EPSS score is notably low (0.02%, 5th percentile) with SSVC indicating no observed exploitation and partial technical impact, suggesting limited real-world targeting despite the high-severity nature of root code execution. No public exploit code identified at time of analysis.

Unprivileged local users on FreeBSD can read sensitive kernel memory via a page table manipulation bug in pmap_pkru_update_range(). When applying protection keys to 1GB largepage mappings created through shm_create_largepage(3), the kernel incorrectly treats userspace memory as page table entries, enabling unauthorized information disclosure. This affects FreeBSD 13.5, 14.3, 14.4, and 15.0 releases and has been confirmed fixed by vendor patches.

Local privilege escalation in FreeBSD 13.5 through 15.0 allows unprivileged processes to gain root privileges by exploiting a use-after-free condition in the TIOCNOTTY ioctl implementation. When a process detaches from its controlling terminal and exits, a dangling pointer in the terminal structure references freed session memory, which attackers can manipulate to escalate privileges. This vulnerability affects multiple stable and release branches with CVSS 8.4 (High) but low EPSS probability (0.02%, 5th percentile), indicating theoretical severity without observed widespread exploitation. Not listed in CISA KEV, suggesting no confirmed active exploitation at time of analysis.

Packet filter (pf) rule hash calculation regression in FreeBSD causes rules with address range syntax (x.x.x.x - y.y.y.y) differing only in address ranges to be silently dropped as duplicates, loading only the first rule and potentially causing unexpected packet filtering behavior including unintended blocking or allowing of traffic. The regression affects pf's duplicate detection mechanism but does not impact rules using CIDR notation (address/mask-bits syntax). Only the first of multiple such rules is loaded, creating a silent configuration failure with no warning to administrators.

Remote code execution in FreeBSD kernel's RPCSEC_GSS implementation (kgssapi.ko) and userspace RPC servers (librpcgss_sec) allows low-privileged authenticated attackers to execute arbitrary code via crafted network packets. Affects FreeBSD 13.5, 14.3, 14.4, and 15.0 branches. Publicly available exploit code exists (GitHub/Gist), though EPSS probability remains low (0.05%, 16th percentile) and CISA has not listed this in KEV, suggesting limited observed exploitation despite high CVSS 8.8 score and total technical impact per SSVC framework.

NVMe/TCP targets are vulnerable to unauthenticated denial of service when a remote attacker sends a CONNECT command with an invalid CNTLID, triggering a kernel panic on the exposed system. The vulnerability exploits a null pointer dereference that allows any network-accessible attacker to crash the target without authentication. No patch is currently available for this high-severity flaw.

This vulnerability is a memory leak in FreeBSD's TCP stack where the tcp_respond() function fails to properly free allocated memory buffers (mbufs) when challenge ACKs are not sent in response to crafted packets. FreeBSD systems of all versions are affected. An attacker with network access (either on-path with an established connection or able to establish one, or via spoofed packets) can trigger this leak repeatedly by sending specially crafted packets that exceed rate limits, causing heap exhaustion and potential denial of service through resource depletion.

The rtsock_msg_buffer() function serializes routing information into a buffer. As a part of this, it copies sockaddr structures into a sockaddr_storage structure on the stack. [CVSS 7.5 HIGH]

FreeBSD's blocklistd service leaks socket descriptors on each adverse event report, causing progressive service degradation until it can no longer block malicious IP addresses or process new reports. An attacker can exploit this by generating numerous fraudulent adverse events from disposable IP addresses to exhaust socket resources and disable the blocking mechanism before launching an actual attack. The vulnerability has a high severity rating (CVSS 7.5) and currently lacks a patch.

If two sibling jails are restricted to separate filesystem trees, which is to say that neither of the two jail root directories is an ancestor of the other, jailed processes may nonetheless be able to access a shared directory via a nullfs mount, if the administrator has configured one. [CVSS 7.5 HIGH]

By default, jailed processes cannot mount filesystems, including nullfs(4). However, the allow.mount.nullfs option enables mounting nullfs filesystems, subject to privilege checks. [CVSS 8.8 HIGH]

In some cases, the `tcp-setmss` handler may free the packet data and throw an error without halting the rule processing engine. A subsequent rule can then allow the traffic after the packet data is gone, resulting in a NULL pointer dereference. [CVSS 7.5 HIGH]

The rtsol(8) and rtsold(8) programs do not validate the domain search list options provided in router advertisement messages; the option body is passed to resolvconf(8) unmodified. resolvconf(8) is a shell script which does not validate its input. [CVSS 7.2 HIGH]

The ctl_write_buffer and ctl_read_buffer functions allocated memory to be returned to userspace, without initializing it. Rated high severity (CVSS 8.8), this vulnerability is low attack complexity. No vendor patch available.

The function ctl_write_buffer incorrectly set a flag which resulted in a kernel Use-After-Free when a command finished processing. Rated high severity (CVSS 8.8), this vulnerability is low attack complexity. No vendor patch available.

The ctl_request_sense function could expose up to three bytes of the kernel heap to userspace. Rated high severity (CVSS 8.8), this vulnerability is low attack complexity. No vendor patch available.

Concurrent removals of certain anonymous shared memory mappings by using the UMTX_SHM_DESTROY sub-request of UMTX_OP_SHM can lead to decreasing the reference count of the object representing the. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

The ctl_report_supported_opcodes function did not sufficiently validate a field provided by userspace, allowing an arbitrary write to a limited amount of kernel help memory. Rated high severity (CVSS 8.8), this vulnerability is low attack complexity. No vendor patch available.

An insufficient boundary validation in the USB code could lead to an out-of-bounds write on the heap, with data controlled by the caller. Rated high severity (CVSS 8.2), this vulnerability is low attack complexity. No vendor patch available.

A malicious value of size in a structure of packed libnv can cause an integer overflow, leading to the allocation of a smaller buffer than required for the parsed data. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

A signal handler in sshd(8) may call a logging function that is not async-signal-safe. Rated high severity (CVSS 8.1), this vulnerability is remotely exploitable, no authentication required. No vendor patch available.

A logic bug in the code which disables kernel tracing for setuid programs meant that tracing was not disabled when it should have, allowing unprivileged users to trace and inspect the behavior of. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

When mounting a remote filesystem using NFS, the kernel did not sanitize remotely provided filenames for the path separator character, "/". Rated medium severity (CVSS 5.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

Remote code execution in OpenSSH's sshd server (regression of CVE-2006-5051) allows unauthenticated remote attackers to exploit a signal handler race condition by failing to authenticate within the LoginGraceTime window, potentially yielding root-level code execution on glibc-based Linux systems. The flaw - widely known as 'regreSSHion' - affects numerous distributions and vendor appliances including Ubuntu 23.10/24.04, AlmaLinux 9, SonicWall SMA firmware, Arista EOS, NetApp ONTAP, and others. Publicly available exploit code exists and EPSS scores it at 48.06% (98th percentile), reflecting very high exploitation likelihood, though it is not currently listed in CISA KEV.

NFS in a BSD derived codebase, as used in OpenBSD through 7.4 and FreeBSD through 14.0-RELEASE, allows remote attackers to execute arbitrary code via a bug that is unrelated to memory corruption. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available and no vendor patch available.

The jail(2) system call has not limited a visiblity of allocated TTYs (the kern.ttys sysctl). Rated low severity (CVSS 3.3), this vulnerability is low attack complexity. No vendor patch available.

`bhyveload -h <host-path>` may be used to grant loader access to the <host-path> directory tree on the host. Rated medium severity (CVSS 6.3), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

sendmail through 8.17.2 allows SMTP smuggling in certain configurations. Rated medium severity (CVSS 5.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available.

The SSH transport protocol with certain OpenSSH extensions, found in OpenSSH before 9.6 and other products, allows remote attackers to bypass integrity checks such that some packets are omitted (from. Rated medium severity (CVSS 5.9), this vulnerability is remotely exploitable, no authentication required. Public exploit code available and EPSS exploitation probability 53.6%.

When a program running on an affected system appends data to a file via an NFS client mount, the bug can cause the NFS client to fail to copy in the data to be written but proceed as though the copy. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

In versions of FreeBSD 14.0-RELEASE before 14-RELEASE-p2, FreeBSD 13.2-RELEASE before 13.2-RELEASE-p7 and FreeBSD 12.4-RELEASE before 12.4-RELEASE-p9, the pf(4) packet filter incorrectly validates. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

In versions of FreeBSD 13-RELEASE before 13-RELEASE-p5, under certain circumstances the cap_net libcasper(3) service incorrectly validates that updated constraints are strictly subsets of the active. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

In versions of FreeBSD 12.4-RELEASE prior to 12.4-RELEASE-p7 and FreeBSD 13.2-RELEASE prior to 13.2-RELEASE-p5 the __sflush() stdio function in libc does not correctly update FILE objects' write. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

On CPU 0 the check for the SMCCC workaround is called before SMCCC support has been initialized. Rated medium severity (CVSS 5.5), this vulnerability is low attack complexity. No vendor patch available.

Before correction, the copy_file_range system call checked only for the CAP_READ and CAP_WRITE capabilities on the input and output file descriptors, respectively. Rated high severity (CVSS 7.1), this vulnerability is low attack complexity. No vendor patch available.

On an msdosfs filesystem, the 'truncate' or 'ftruncate' system calls under certain circumstances populate the additional space in the file with unallocated data from the underlying disk device,. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity.

In pf packet processing with a 'scrub fragment reassemble' rule, a packet containing multiple IPv6 fragment headers would be reassembled, and then immediately processed. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

The fwctl driver implements a state machine which is executed when a bhyve guest accesses certain x86 I/O ports. Rated high severity (CVSS 8.8), this vulnerability is low attack complexity. No vendor patch available.

A set of carefully crafted ipv6 packets can trigger an integer overflow in the calculation of a fragment reassembled packet's payload length field. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

pam_krb5 authenticates a user by essentially running kinit with the password, getting a ticket-granting ticket (tgt) from the Kerberos KDC (Key Distribution Center) over the network, as a way to. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.