CVE-2026-89676 is a critical vulnerability in the Linux kernel's NFS server (nfsd) related to stale state ID entries in the async COPY operation. The flaw involves improper handling of state IDs in the s2s_cp_stateids IDR, leading to potential use-after-free conditions when IDR walkers dereference memory that has been reused by subsequent requests. This can cause kernel memory corruption and potentially allow for denial of service or privilege escalation. The issue affects Linux kernel version 4.20 and has been fixed in several subsequent commits.
CVE-2026-89652 is a critical buffer overflow vulnerability in the Linux kernel's Ceph filesystem NFS export code. It occurs due to an unchecked copy of a directory entry name length, which can lead to out-of-bounds writes when a malicious or compromised Ceph Metadata Server returns an excessively long name. This affects the ceph_get_name() and __get_snap_name() functions and is exploitable when a CephFS mount is re-exported over NFS. A fix has been implemented to bound the copied name length and prevent overflow.
In the Linux kernel, the following vulnerability has been resolved: fbdev: serialize mode sysfs access with lock_fb_info() show_mode(), show_modes(), and store_mode() access fb_info->modelist and fb_info->mode without holding lock_fb_info(). store_modes() takes lock_fb_info() while replacing the modelist and freeing the old one. A concurrent reader or writer can load a pointer to an old modelist entry before store_modes() frees it, then dereference freed memory or store a stale freed pointer in fb_info->mode. Take lock_fb_info() in show_mode(), show_modes(), and store_mode() to serialize with store_modes(). In show_mode(), copy the mode to the stack and format after dropping the lock. In store_mode(), split activate() into a _locked variant to avoid double-locking, and hold the locks for the modelist walk, mode conversion, activation, and fb_info->mode assignment together.
A vulnerability was found in NousResearch hermes-agent 0.18.0. This vulnerability affects the function resourceBufferFromUrl of the file apps/desktop/electron/main.ts of the component Electron Main Process. Performing a manipulation results in allocation of resources. The attack may be initiated remotely. copyImageFromUrl() entry point no longer reachable on current main. That function did exist at v2026.8.3 but was removed by v2026.8.19. The modern copy-image path is Electron-native event.sender.copyImageAt().
This entry is a guest diary post on the SANS Internet Storm Center by an intern, discussing topics related to Honeypot-Omaha and batch.py. The content appears to be informational and does not describe a specific security vulnerability or active threat. There is no indication of affected software versions, exploitation, or remediation details.
pypdf is a free and open-source pure-python PDF library. Prior to 6.16.1, an attacker can craft a PDF that causes pypdf/_doc_common.py _get_outline to consume long runtimes and large amounts of memory when retrieving document outlines with large numbers of entries or deeply nested reused paths because the traversal lacked global entry-count and nesting-depth limits. This issue is fixed in version 6.16.1.
Wallos is an open-source, self-hostable personal subscription tracker. Prior to version 4.9.6, POST /endpoints/db/restore.php calls ZipArchive::extractTo() without validating entry names for ../ sequences. Admin uploads crafted zip with entry logos/../../endpoints/shell.php to write webshell to webroot. Extension filter only applies to post-extraction logo copy step. This issue has been patched in version 4.9.6.
This entry references a GitHub account hosting a collection of Python networking and cybersecurity projects. The content is a link post from a Reddit cybersecurity subreddit where the user shares their GitHub repository containing tools for host discovery, port scanning, TCP communication, banner grabbing, and service enumeration. There is no indication of a security vulnerability, exploit, or active threat associated with this repository or account.
In the Linux kernel, the following vulnerability has been resolved: tls: don't leave a full plaintext sk_msg ring unpushed When the copy path in tls_sw_sendmsg_locked() adds the fragment that fills the plaintext sk_msg ring, it does not set full_record, so the record is left full and unpushed. A later splice() then adds to an already full ring: sk_msg_page_add() has no fullness check of its own, so sg.end wraps onto sg.start and the ring appears empty. Fragments added after that overwrite live entries, and sg.size no longer matches what is reachable between sg.start and sg.end, so pushing the record runs the scatterwalk off the end of the scatterlist. An unprivileged user can trigger this on a loopback TCP socket with the "tls" ULP attached: BUG: kernel NULL pointer dereference, address: 0000000000000008 RIP: 0010:memcpy_from_scatterwalk+0x32/0xc0 Call Trace: skcipher_walk_next+0x1d1/0x2c0 gcm_encrypt_aesni_avx+0x1e9/0x220 bpf_exec_tx_verdict+0x3bb/0x860 tls_sw_sendmsg+0xa1a/0xca0 __sys_sendto+0x1da/0x1f0 Set full_record in the copy path when the ring becomes full, and push a record that is already full on entry to the sendmsg loop.
SitemapLoader.parse_sitemap in langchain_community/document_loaders/sitemap.py applies the documented restrict_to_same_domain control only to leaf url entries. The loop over url elements filters cross-domain locations, but the loop over nested sitemap elements passes the child loc straight to self.scrape_all([loc.text], "xml"), which reaches WebBaseLoader.scrape_all and an aiohttp GET, with no domain comparison and no check for private, loopback or link-local destinations. An attacker who controls or influences an ingested sitemap can therefore point a nested sitemap entry at an internal address and make the server fetch it even when the deploying application set restrict_to_same_domain to True specifically to confine outbound requests. The fetched content is parsed and surfaces in the returned Documents, so internal responses are disclosed to the caller rather than merely requested.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (50f3053643e65c63fa7d8e3d5c48ae3d659650bd0052137099cd8674232780bc)
Package publishes as `mc-registry` with description 'Theta chain registry', but its README, badges, homepage layout, and package listing copy the legitimate hyperweb-io/chain-registry npm package. The README instructs users to `npm install theta-registry` and `import { assets, chains, ibc } from 'theta-registry'`, while the shipped name is `mc-registry` and the shipped API diverges from chain-registry by re-exporting `HttpProvider` from an unrelated third-party dependency `chain-analyze` (`^1.0.4`). The ESM entry `esm/index.js` performs `import { HttpProvider } from 'chain-analyze';` at top level, so any consumer that does `import 'mc-registry'` loads and executes `chain-analyze` code in the installer/consumer process. `chain-analyze` is not part of the chain-registry ecosystem and has no relationship to the advertised 'chain registry' data purpose. The internal accessor is named `loadPartnerVaultHttpProvider`, further indicating the module funnels callers into an unvetted HTTP provider from the injected dependency. Files `esm/mainnet/persistence/chain.js` and `mainnet/persistence/chain.js` contain `ping`/`POST` network patterns co-located with chain persistence logic.
## Source: ghsa-malware (1a64395cf18ef215fa8debd38d127b7f163f4d347bc898101e13937d3df306bf)
Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it.
Malcolm's upload-processing pipeline (scripts/safe-extract.py) enforces entry-count, nesting-depth, and total-uncompressed-byte limits when extracting container archives (zip/tar/rar/7z via libarchive), but those limits are not applied when the uploaded file is a single-stream compressed format (.gz, .bz2, .xz, .lzma, .lz) that isn't a .tar.*-style archive. Any authenticated user permitted to upload PCAP/log files can upload a small, highly compressible file (e.g. a gzip bomb) that decompresses to an effectively unbounded size on disk, exhausting the shared Docker volume used by OpenSearch, Logstash, Arkime, and Zeek, and disrupting the platform for all users.
In the Linux kernel, the following vulnerability has been resolved: LoongArch: Fix missing dirty page tracking in {pte,pmd}_wrprotect() When hardware page table walker (PTW) is enabled on LoongArch, the CPU may set _PAGE_DIRTY directly in the page table entry during a write TLB miss, without going through the software TLB store handler. The software TLB store handler (tlbex.S:254) sets both _PAGE_DIRTY and_PAGE_MODIFIED together: ori t0, t0, (_PAGE_VALID | _PAGE_DIRTY | _PAGE_MODIFIED) Since hardware PTW only sets _PAGE_DIRTY, the software-only bit, i.e. _PAGE_MODIFIED is left unchanged. This creates a window where a PTE has _PAGE_DIRTY set (hardware knows the page is dirty) but _PAGE_MODIFIED clear (software is unaware). When fork()/clone() triggers copy-on-write, __copy_present_ptes() calls pte_wrprotect(), which unconditionally clears both the _PAGE_WRITE and _PAGE_DIRTY bits: pte_val(pte) &= ~(_PAGE_WRITE | _PAGE_DIRTY); Since _PAGE_MODIFIED was never set, the dirtiness information is lost completely. Subsequently, when memory pressure triggers page reclaim, page_mkclean() / try_to_unmap() sees the page as clean (i.e. pte_dirty() returns false) and the page may be freed without writeback, causing data corruption. Fix this by propagating the _PAGE_DIRTY bit to the _PAGE_MODIFIED bit in both pte_wrprotect() and pmd_wrprotect() before clearing writeable bits: if (pte_val(pte) & _PAGE_DIRTY) pte_val(pte) |= _PAGE_MODIFIED; The pmd_wrprotect() fix handles the CONFIG_TRANSPARENT_HUGEPAGE case, where pmd entries need the same treatment. This ensures the software dirty tracking bit (checked by pte_dirty() and pmd_dirty(), which read both the _PAGE_DIRTY and _PAGE_MODIFIED bits) is preserved across fork COW write-protection. The issue was found by the LTP madvise09 test case, which exercises page reclaim after "madvise(MADV_FREE), write and fork" operation sequence on private anonymous mappings.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (832d1ce61ce1f1e1430c60e94175cc80700dfbb2f8d0f46fd7d00b64720026d8)
Package publishes under a lodash-imitating identity: keywords `lodash`/`lodash-js`, and the README is a verbatim copy of the official lodash 4.18.1 README. The single shipped file `dist/common-js.js` is not lodash — it is a ~770 KB javascript-obfuscator bundle (17,969-entry rotated string array, `_0xNNNN` identifiers). After deobfuscation the bundle is a browser-based cryptocurrency-mining client: it opens a WebSocket to a caller/config-supplied pool URL, spawns a fan-out of Web Workers keyed by `workerId`, handles `nonce` framing, and bundles an AES-GCM decryption primitive (`aesGcmDecrypt` from @noble/ciphers) for pool message decryption. Wallet and worker identifiers are read from a config object with fallbacks (`cfg.wallet||'x'`, `cfg.worker||'worker'`). A developer who installs this expecting a lodash-family utility and ships it in a web application will silently mine cryptocurrency on their end users' browsers, consuming visitor CPU/battery and creating a compliance/abuse liability for the downstream site. The identity masquerade (name/keywords/README all mimicking lodash) combined with heavy string-array obfuscation of the real payload is the standard shape of a supply-chain masquerade attack.
In the Linux kernel, the following vulnerability has been resolved: veth: convert frag_list skbs before running XDP A frag_list skb can reach veth with data_len set but nr_frags zero. veth_convert_skb_to_xdp_buff() only converts skbs that are shared, locked, have frags[], or do not have enough headroom. It later uses skb_is_nonlinear() to decide whether to set XDP_FLAGS_HAS_FRAGS and xdp_frags_size. That exposes frag_list data to XDP as if it were stored in frags[], but frags[] is empty. AF_XDP copy mode can then trust the bogus XDP fragment metadata, walk an empty fragment entry, and crash in memcpy() from __xsk_rcv(). Route non-linear skbs through skb_pp_cow_data() before exposing them to XDP, and only advertise XDP frags when the resulting skb has frags[]. skb_copy_bits() already handles frag_list input, and skb_pp_cow_data() builds frags[] output with skb_add_rx_frag(), which is the representation XDP multi-buffer expects.
In the Linux kernel, the following vulnerability has been resolved: netfilter: ipset: do not update comments from kernel-side hash adds mtype_resize() copies comment pointers with memcpy(), not the comment objects themselves. During the window after an entry has been copied but before the table swap and backlog replay, the old table is still published for packet-side updates while the replacement-table entry already holds the same ip_set_comment_rcu pointer. If xt_SET --add-set ... --exist hits that old entry in this window, mtype_add() calls ip_set_init_comment() even though packet-side adds carry no comment payload. That call frees the shared comment through the old entry, so the replacement-table entry now holds a stale pointer. When the queued add is replayed on the new table, mtype_add() calls ip_set_init_comment() again and strlen() dereferences the stale pointer. Fix this in mtype_add() by skipping ip_set_init_comment() when ext->target marks a packet-side add. Userspace adds still update comments, while packet-side adds can no longer free comment storage shared with a resize copy.
A concurrency vulnerability in the Linux kernel's KVM TDX implementation allowed userspace to change the CPUID entry count during initialization, potentially causing out-of-bounds access during CPUID parsing. This flaw was fixed by rejecting KVM_TDX_INIT_VM requests if the CPUID entry count changes between initial read and data copy.
A vulnerability in the Linux kernel's NTFS3 filesystem driver was resolved, involving an unbounded memmove length in the DeleteIndexEntryAllocation function. The issue arises when a size value from an on-disk INDEX_BUFFER entry causes a pointer offset calculation to underflow and be cast to a large size_t, leading memmove to copy beyond the destination buffer. This can cause a kernel crash (oops). The flaw was reproduced with a crafted NTFS image and fixed by adding proper bounds checks and rejecting zero-length entries.
A vulnerability in the Linux kernel's xen/gntdev ioctl error handling was fixed. The flaw caused a memory leak and dangling list entry when gntdev_ioctl_map_grant_ref() failed to copy results back to userspace after adding a mapping. The issue stemmed from not releasing a reference acquired by gntdev_alloc_map() on error. Additionally, the mapping index returned to userspace could be incorrect due to modifications by gntdev_add_map(). The fix involves proper mutex handling, retrieving the correct index, and cleanup on copy_to_user() failure.
CVE-2026-22691 is a vulnerability in the pdfly product affecting pypdf versions >=0.4.0 and <0.5.1_5. It allows an attacker to craft a malformed PDF with an invalid startxref entry that causes possibly long runtimes when the cross-reference table is rebuilt in non-strict reading mode. This issue has been fixed in version 0.5.1_5. Users can mitigate by upgrading or using strict mode when reading PDFs.