Search: im-inter.net
19 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| High | 7.8 | EPSS 0.2% | High7.8EPSS 0.2%GCVE DatabaseCVE-2026-99054 CVE-2026-99054 is a high-severity vulnerability in the Linux kernel's TIPC (Transparent Inter-Process Communication) subsystem. The flaw involves improper teardown of topology server workqueues before closing subscriber connections, leading to race conditions. This can cause use-after-free errors, queueing work on destroyed workqueues, and RCU stalls during network exit. The vulnerability has been addressed by changing the teardown order, adding shutdown flags, refusing lookups after shutdown, and properly destroying workqueues before closing connections. | GCVE Database | ||
| Medium | 6.9 | EPSS 0.4% | Medium6.9EPSS 0.4%CVE Database V5CVE-2026-109441 LangAlpha through 2026.09.07 contains an improper isolation vulnerability that places all tenants' sandbox containers on Docker's shared default bridge network with inter-container communication enabled. Authenticated users with code execution in their own sandbox can connect directly to other tenants' containers, bypassing require_workspace_owner checks to read files such as vault secrets from exposed servers. EPSS 0.4%Vulnerability | CVE Database V5 | ||
| Critical | 9.8 | EPSS 1.0% | CVE-2026-105192LMCache · Remote code execution via unsafe deserialization in multiprocess mode transport Critical9.8EPSS 1.0%GCVE DatabaseCVE-2026-105192 LMCache versions from 0.3.9 up to but not including 0.5.6 have a critical unauthenticated remote code execution vulnerability in multiprocess mode via unsafe pickle deserialization on the ZeroMQ transport port (default 5555). The transport socket, used for inter-process communication, lacks authentication and deserializes attacker-controlled data using pickle.loads, allowing arbitrary code execution as the LMCache process user. By default, the transport binds to localhost, but multi-node deployments often bind to routable addresses, exposing the service. Official container images run the LMCache process as root, increasing risk. The vulnerability is fixed in version 0.5.6 by replacing pickle with a safe, versioned MessagePack format and restricting network exposure. | GCVE Database | ||
| –Not rated | – | AlienVault OTX General In September 2024, a sophisticated multi-stage intrusion targeted a telecommunications organization by exploiting CVE-2024-47575 on a FortiManager appliance to exfiltrate configurations and cryptographic material for over 500 FortiGate firewalls. Subsequently, attackers exploited CVE-2025-61624 to deploy PEERSTITCH, a novel ARM64 memory-resident malware implant that avoids disk and network detection. The implant patches running processes, creates covert inter-process communication channels, and intercepts network traffic. Additional attack techniques included using Apache mod_md for reverse shell command and control, impersonating FortiManager to compromise downstream devices, and employing extensive anti-forensic measures. The attack demonstrates advanced tradecraft consistent with nation-state actors and highlights the critical risk of centralized edge management platforms. | AlienVault OTX General | |||
| –Not rated | – | AlienVault OTX General A modular espionage framework targeting entities in Israel has evolved to incorporate sophisticated command-and-control capabilities. The framework employs DNS A-record responses to dynamically select between direct HTTPS connections and a Google Apps Script relay for each transaction, enabling operators to rotate communication channels and deployment identifiers. The communication module uses DNS infrastructure to validate and update Google Apps Script deployment IDs, while XOR encoding obfuscates command-and-control traffic. An inter-component broker coordinates framework DLL components, enabling runtime upgrades without system restarts. The infrastructure leveraged a previously expired Israeli domain, now repurposed with custom authoritative DNS servers, alongside legitimate Google services to blend malicious traffic with normal network activity. | AlienVault OTX General | |||
| High | 7.8 | EPSS 0.1% | High7.8EPSS 0.1%GCVE DatabaseCVE-2026-64543 A use-after-free vulnerability in the Linux kernel's Transparent Inter-Process Communication (TIPC) subsystem was fixed. The flaw involves improper freeing and dereferencing of the discoverer structure in tipc_disc_rcv() and bearer_disable(), leading to a potential kernel memory corruption. This vulnerability is reachable from an unprivileged user namespace via the TIPCv2 generic netlink family, which lacks administrative permission checks. The issue affects specific Linux kernel versions and has been addressed by changing the freeing mechanism to use RCU callbacks and adding synchronization barriers during module unload. | GCVE Database | ||
| Critical | 9.4 | EPSS 0.2% | CVE-2026-11746LY Central Dogma · CWE-798 Critical9.4EPSS 0.2%CVE Database V5CVE-2026-11746 ## Vulnerability `ZooKeeperReplicationConfig.secret()` silently substitutes the hard-coded constant `"ch4n63m3"` (leetspeak for "change me") whenever the operator omits `replication.secret`. The same secret is wired into both the **client-facing SASL context** and the **quorum/learner SASL contexts** of the embedded ZooKeeper. The constant is in OSS source on GitHub and is discoverable via code search in seconds. ### Three Reinforcing Defects 1. **OSS-public credential** — `DEFAULT_SECRET` is in `line/centraldogma` source. 2. **Silent fallback** — `firstNonNull(convertValue(...), DEFAULT_SECRET)` substitutes the default with no log, no warning, no startup banner. The only sanity check `checkArgument(!secret().isEmpty(), ...)` passes because the getter substitutes the literal before the emptiness check runs. 3. **Dual-purpose secret** — used for both ZK client-port super auth and inter-peer quorum SASL. A single leaked password authenticates against both surfaces. ### Architecture Context (Important) Central Dogma does **NOT** connect to an external ZooKeeper ensemble. Each replica embeds a `QuorumPeer` (`EmbeddedZooKeeper extends QuorumPeer`) inside its own JVM. The Central Dogma cluster **IS** the ZK ensemble. So the "ZK network" is the inter-replica network of the Central Dogma cluster itself. ### Applicability | `replication.method` | ZK Started? | Applicable? | |---|---|---| | `NONE` (standalone, dev default) | No | **NOT applicable** | | `ZOOKEEPER` (HA production) | Yes, embedded on every replica | **Fully applicable** — canonical production configuration | --- ## Evidence **File:** `server/src/main/java/com/linecorp/centraldogma/server/ZooKeeperReplicationConfig.java` **Branch:** `main` @ commit `d64a5151` **Line 53** — the constant: ```java private static final String DEFAULT_SECRET = "ch4n63m3"; ``` **Lines 210–215** — the silent fallback: ```java /** * Returns the secret string used for authenticating the ZooKeeper peers. */ public String secret() { return firstNonNull(convertValue(secret, "replication.secret"), DEFAULT_SECRET); } ``` --- **File:** `server/src/main/java/com/linecorp/centraldogma/server/internal/replication/ZooKeeperCommandExecutor.java` **Lines 586–607** — JAAS wiring (same secret on both surfaces): ```java final String escapedSecret = jaasValueEscaper.escape(cfg.secret()); ImmutableList.of("Server", EmbeddedZooKeeper.SASL_SERVER_LOGIN_CONTEXT).forEach(name -> { buf.append(name).append(" {").append(newline); buf.append(DigestLoginModule.class.getName()).append(" required").append(newline); buf.append("user_super=\"").append(escapedSecret).append("\";").append(newline); buf.append("};").append(newline); }); ImmutableList.of("Client", EmbeddedZooKeeper.SASL_LEARNER_LOGIN_CONTEXT).forEach(name -> { buf.append(name).append(" {").append(newline); buf.append(DigestLoginModule.class.getName()).append(" required").append(newline); buf.append("username=\"super\"").append(newline); buf.append("password=\"").append(escapedSecret).append("\";").append(newline); buf.append("};").append(newline); }); ``` --- **File:** `server/src/main/java/com/linecorp/centraldogma/server/internal/replication/EmbeddedZooKeeper.java` **Line 44** — proves CD embeds the ZK server: ```java final class EmbeddedZooKeeper extends QuorumPeer { ``` **Lines 213–220** — client port binding (loopback only): ```java private static ServerCnxnFactory createCnxnFactory(QuorumPeerConfig zkCfg) throws IOException { final InetSocketAddress bindAddr = zkCfg.getClientPortAddress(); final ServerCnxnFactory cnxnFactory = ServerCnxnFactory.createFactory(); // Listen only on 127.0.0.1 because we do not want to expose ZooKeeper to others. cnxnFactory.configure(new InetSocketAddress("127.0.0.1", bindAddr != null ? bindAddr.getPort() : 0), zkCfg.getMaxClientCnxns()); return cnxnFactory; } ``` > Quorum/election ports are **NOT** loopback-bound — they bind to `replication.servers[].host` as configured, exposed on the inter-replica network. --- ## PoC Two attack surfaces, two scenarios. **Surface A** (client port, same-host) is implemented as a working read-only PoC. **Surface B** (quorum-port peer impersonation) is documented but intentionally not weaponized. ### Surface A — Same-Host Client Port (Loopback) PoC Python + kazoo + pure-sasl. Authenticates as `super` over SASL DIGEST-MD5 with the leaked secret and reads the full Central Dogma replication log. Hardcoded to `127.0.0.1`, read-only, prints first 5 entries. ```python #!/usr/bin/env python3 """ C3 PoC -- ZooKeeper default-secret takeover (read-only, loopback only). Demonstrates that a Central Dogma instance launched with a ZooKeeper-replicated configuration but without `replication.secret` set exposes its embedded ZooKeeper to anyone with local-host access, using the well-known credential `super / ch4n63m3`. SAFETY: * Hardcoded to 127.0.0.1. Refuses any other targ | CVE Database V5 | ||
| High | – | EPSS 0.6% | CVE-2026-1525Red Hat Security Advisory: nodejs:24 security update HighEPSS 0.6%GCVE DatabaseCVE-2026-1525 Node.js is a software development platform for building fast and scalable network applications in the JavaScript programming language. Security Fix(es): * nodejs: Nodejs denial of service (CVE-2026-21637) * minimatch: minimatch: Denial of Service via specially crafted glob patterns (CVE-2026-26996) * undici: Undici: Denial of Service due to uncontrolled resource consumption (CVE-2026-2581) * undici: Undici: HTTP header injection and request smuggling vulnerability (CVE-2026-1527) * undici: undici: Denial of Service via unbounded memory consumption during WebSocket permessage-deflate decompression (CVE-2026-1526) * undici: Undici: Denial of Service via invalid WebSocket permessage-deflate extension parameter (CVE-2026-2229) * undici: Undici: HTTP Request Smuggling and Denial of Service due to duplicate Content-Length headers (CVE-2026-1525) * undici: undici: Denial of Service via crafted WebSocket frame with large length (CVE-2026-1528) * nghttp2: nghttp2: Denial of Service via malformed HTTP/2 frames after session termination (CVE-2026-27135) * Node.js: Node.js: Denial of Service via malformed Internationalized Domain Name processing (CVE-2026-21712) * Node.js: Node.js: Denial of Service due to crafted HTTP `__proto__` header (CVE-2026-21710) * Node.js: Node.js: Information disclosure due to `fs.realpathSync.native()` bypassing filesystem read restrictions (CVE-2026-21715) * nodejs: Node.js: Permission bypass allows unauthorized modification of file permissions and ownership via incomplete security fix. (CVE-2026-21716) * Node.js: Node.js: Unauthorized inter-process communication due to missing Unix Domain Socket permission checks (CVE-2026-21711) * Node.js: Node.js: Information disclosure via timing oracle in HMAC verification (CVE-2026-21713) * Node.js: Node.js: Memory leak and Denial of Service via crafted HTTP/2 WINDOW_UPDATE frames (CVE-2026-21714) * nodejs: v8: Node.js: Denial of Service via V8 string hashing mechanism due to predictable hash collisions (CVE-2026-21717) For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section. | GCVE Database | ||
| High | 7.1 | EPSS 0.6% | CVE-2026-32769ctfer-io fullchain · Improper Access Control High7.1EPSS 0.6%CVE Database V5CVE-2026-32769 CVE-2026-32769 is a high-severity vulnerability in ctfer-io fullchain versions prior to 0.1.1 caused by an improperly configured NetworkPolicy. This misconfiguration allows a malicious actor who has compromised an application pod to pivot laterally to any pod outside the origin namespace, breaking the expected security-by-default isolation. Exploitation requires no authentication or user interaction and can lead to unauthorized access across namespaces within a Kubernetes cluster. The issue has been fixed in version 0.1.1 by correcting the NetworkPolicy. Until patching, deleting the problematic inter-ns- prefixed NetworkPolicy in the target namespace can mitigate the risk. This vulnerability impacts confidentiality and integrity by enabling lateral movement and potential further compromise within containerized environments. | CVE Database V5 | ||
| High | 7.9 | EPSS 0.4% | CVE-2026-32737ctfer-io romeo · Improper Access Control High7.9EPSS 0.4%CVE Database V5CVE-2026-32737 Romeo gives the capability to reach high code coverage of Go ≥1.20 apps by helping to measure code coverage for functional and integration tests within GitHub Actions. Prior to version 0.2.1, due to a mis-written NetworkPolicy, a malicious actor can pivot from the "hardened" namespace to any Pod out of it. This breaks the security-by-default property expected as part of the deployment program, leading to a potential lateral movement. Removing the `inter-ns` NetworkPolicy patches the vulnerability in version 0.2.1. If updates are not possible in production environments, manually delete `inter-ns` and update as soon as possible. Given one's context, delete the failing network policy that should be prefixed by `inter-ns-` in the target namespace. | CVE Database V5 | ||
| Medium | 5.4 | EPSS 0.3% | Medium5.4EPSS 0.3%CVE Database V5CVE-2026-23809 A technique has been identified that adapts a known port-stealing method to Wi-Fi environments that use multiple BSSIDs. By leveraging the relationship between BSSIDs and their associated virtual ports, an attacker could potentially bypass inter-BSSID isolation controls. Successful exploitation may enable an attacker to redirect and intercept the victim's network traffic, potentially resulting in eavesdropping, session hijacking, or denial of service. | CVE Database V5 | ||
| –Not rated | – | Reddit InfoSec News The Marquis data breach has compromised sensitive information from over 74 US banks and credit unions, representing a significant security incident in the financial sector. Although the breach primarily affects US institutions, European organizations connected to these banks or using related services could face indirect risks such as fraud or phishing attacks leveraging stolen data. The breach's high severity is due to the potential exposure of confidential financial and personal data, which could lead to identity theft, financial fraud, and reputational damage. No known exploits are currently active in the wild, but the breach's scale and sensitivity warrant immediate attention. European financial institutions should review their exposure to affected US entities and enhance monitoring for suspicious activities. Mitigation should focus on strengthening inter-organizational data sharing security, improving anomaly detection, and educating customers about potential phishing attempts. Countries with strong financial ties to the US and significant banking sectors, such as the United Kingdom, Germany, France, and the Netherlands, are most likely to be impacted. Given the breach's scope, ease of exploitation (via data theft), and high impact on confidentiality and integrity, the suggested severity is high. Defenders must prioritize incident response, cross-border collaboration, and customer communication to mitigate downstream effects. | Reddit InfoSec News | |||
| –Not rated | – | Reddit InfoSec News APT31, a China-linked advanced persistent threat group, has launched stealthy cyberattacks targeting Russian IT infrastructure by leveraging cloud services. These attacks are characterized by their covert nature, aiming to infiltrate and maintain persistence within Russian organizations' networks. Although no specific vulnerabilities or exploits have been publicly detailed, the use of cloud services as an attack vector suggests sophisticated tactics to evade detection and exploit trusted platforms. The threat poses significant risks to confidentiality and integrity of targeted systems, with potential for espionage or disruption. European organizations, especially those with close ties to Russian entities or using similar cloud platforms, could face indirect risks. Mitigation requires enhanced monitoring of cloud service usage, strict access controls, and threat hunting focused on stealthy behaviors. Countries with strong economic or political connections to Russia and high cloud adoption rates are most likely to be affected. Given the stealth, high impact potential, and lack of required user interaction, this threat is assessed as high severity. Defenders should prioritize detection capabilities and inter-organizational information sharing to counter this evolving threat. | Reddit InfoSec News | |||
| –Not rated | – | Reddit NetSec This security news discusses Android Intents, focusing on their operation, security implications, and examples of attacks such as intent hijacking. Android Intents are a core IPC (inter-process communication) mechanism that allows apps to request actions from other components or apps. Improper handling or exposure of Intents can lead to vulnerabilities like intent hijacking, where malicious apps intercept or manipulate Intents to gain unauthorized access or perform malicious actions. Although no specific affected versions or known exploits are reported, the threat highlights the medium severity risks associated with insecure Intent usage. European organizations using Android-based mobile devices or developing Android apps should be aware of these risks. Mitigations include secure Intent handling, explicit component targeting, and permission enforcement. Countries with large Android user bases and mobile development ecosystems, such as Germany, France, and the UK, are more likely to be affected. The suggested severity is medium due to the potential confidentiality and integrity impacts, moderate exploitation difficulty, and the need for user interaction or app installation. | Reddit NetSec | |||
| High | – | EPSS 0.2% | HighEPSS 0.2%GCVE DatabaseCVE-2025-21701 This security update for the Linux Kernel 5.14.21-150500_55_110 addresses multiple vulnerabilities including a use-after-free (UAF) in the HFSC queuing discipline, race conditions in network device unregistration, and protection improvements for IPCS lookups. The fixes resolve issues that could affect network scheduling and inter-process communication subsystems. | GCVE Database | ||
| Medium | – | MediumReddit NetSec Microsoft Remote Procedure Call (MS-RPC) is a protocol used within Windows operating systems to enable inter-process communication, both locally and across networks. Researching MS-RPC interfaces, however, poses several challenges. Manually analyzing RPC services can be time-consuming, especially when faced with hundreds of interfaces spread across different processes, services and accessible through various endpoints. This post will dive into the new algorithm/method I designed and implemented for fuzzing. It will describe some results and why these results differ from the default fuzzing approach. Apart from the additional implemented features, the tool will be released with this post as well! All security researchers from over the world can now freely use this tool in their research. | Reddit NetSec | |||
| High | 8.8 | EPSS 0.6% | High8.8EPSS 0.6%GCVE DatabaseCVE-2025-38052 CVE-2025-38052 is a high-severity use-after-free vulnerability in the Linux kernel's Transparent Inter-Process Communication (TIPC) network protocol implementation. The flaw occurs in the tipc_aead_encrypt_done function, where a slab-use-after-free condition can be triggered after a network namespace deletion, leading to a read of freed memory. This issue arises when encryption operations are interrupted and a cryptographic worker thread accesses freed resources. The vulnerability has been fixed in several Linux kernel versions starting from 5.15.0-1083.86~20.04.1 and later. EPSS 0.6%Vulnerability | GCVE Database | ||
| Medium | 4.4 | EPSS 0.2% | CVE-2024-51330Cura · Code Injection Medium4.4EPSS 0.2%CVE Database V5CVE-2024-51330 An issue in UltiMaker Cura v.4.41 and 5.8.1 and before allows a local attacker to execute arbitrary code via Inter-process communication (IPC) mechanism between Cura application and CuraEngine processes, localhost network stack, printing settings and G-code processing and transmission components, Ultimaker 3D Printers. | CVE Database V5 |
Page 1 of 2 · 2 duplicate CVE records merged