Search: time-local.net
290 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| High | 7.8 | EPSS 0.1% | CVE-2026-74496Linux kernel · fou: Fix use-after-free in fou_create() High7.8EPSS 0.1%GCVE DatabaseCVE-2026-74496 In the Linux kernel, the following vulnerability has been resolved: fou: Fix use-after-free in fou_create() fou_create() publishes struct fou through sk_user_data before adding the new FOU port to the per-netns list. If fou_add_to_port_list() fails, the error path frees fou while it is still reachable through sk_user_data. A concurrent receive can then dereference the freed object in fou_from_sock(). This ordering issue was previously noted in the linked discussion. The failure is reachable when local port 0 is requested. Each socket binds to a different ephemeral port, but fou_cfg_cmp() compares the requested port 0 and reports -EALREADY once an entry already exists. Release the tunnel socket before freeing fou so sk_user_data is cleared first, and defer reclamation with kfree_rcu() to protect concurrent RCU readers. This matches the lifetime handling in fou_release(). | GCVE Database | ||
| High | 7.8 | EPSS 0.1% | High7.8EPSS 0.1%GCVE DatabaseCVE-2026-72405 A use-after-free vulnerability was identified and resolved in the Linux kernel's udp_tunnel subsystem. The flaw involved double queueing of work items in udp_tunnel_nic_device_sync(), leading to a race condition where a structure could be freed while still in use. This could result in memory corruption and potentially allow an attacker with local privileges to compromise system integrity. The issue affects specific Linux kernel versions and has been fixed by preventing redundant work queueing. The vulnerability has a high severity rating and a CVSS score of 7.8. | GCVE Database | ||
| High | 7.8 | EPSS 0.2% | High7.8EPSS 0.2%GCVE DatabaseCVE-2026-74283 A vulnerability in the Linux kernel's TIPCv2 netlink mutators allowed local unprivileged users to change TIPC state without requiring administrative privileges. This was due to missing CAP_NET_ADMIN permission checks on certain generic netlink operations. The issue has been fixed by enforcing the appropriate admin permission flags, aligning TIPCv2 behavior with the legacy TIPC netlink API. Exploitation attempts that previously succeeded now fail with permission errors after applying the patch. EPSS 0.2%Vulnerability | GCVE Database | ||
| Low | 6.3 | EPSS 0.2% | Low6.3EPSS 0.2%GCVE DatabaseCVE-2026-72349 A vulnerability in the Linux kernel's netfilter xt_rateest module caused incorrect byte rate comparisons on links faster than approximately 34 Gbps due to 32-bit truncation of 64-bit values. This flaw was fixed by changing local variables to 64-bit integers to correctly handle high byte rates. | GCVE Database | ||
| High | 7.8 | EPSS 0.2% | High7.8EPSS 0.2%GCVE DatabaseCVE-2026-72232 A vulnerability in the Linux kernel's batman-adv subsystem could allow a local user with eBPF TC hook access to cause out-of-bounds memory reads by attaching a tc filter that truncates packets and redirects them to a batadv interface. The issue arises because the code assumes the presence of a minimal Ethernet header length without verifying buffer availability. This flaw has been fixed in multiple patched Linux kernel versions. EPSS 0.2%Vulnerability | GCVE Database | ||
| High | 7.1 | EPSS 0.1% | High7.1EPSS 0.1%GCVE DatabaseCVE-2026-72049 A vulnerability in the Linux kernel's ieee802154 subsystem allows any local user to read raw AES-128 LLSEC keys from the kernel keytable on any WPAN network device with an installed LLSEC key. This occurs because legacy LLSEC dump operations lack proper administrative gating, exposing sensitive cryptographic keys. The issue is fixed by introducing permission checks requiring administrative privileges for these dump operations. | GCVE Database | ||
| Medium | 6.6 | EPSS 0.4% | CVE-2026-53708ContextForge · DNS TOCTOU race condition causes SSRF protection bypass (`/admin/gateways/test`) Medium6.6EPSS 0.4%GCVE DatabaseCVE-2026-53708 ContextForge is an AI gateway, registry, and proxy that provides centralized discovery, guardrails, and management for MCP, A2A, and REST or gRPC APIs. Prior to 1.0.3, the /admin/gateways/test call site in mcpgateway/admin.py calls validate_gateway_test_url() in mcpgateway/common/validators.py to resolve and reject private, loopback, link-local, and cloud-metadata addresses, but ResilientHttpClient later resolves the original hostname again without binding the validated address. When MCPGATEWAY_ADMIN_API_ENABLED is enabled, an attacker with a database-backed role containing explicit gateways.read permission can use DNS rebinding to return a public address during validation and a private or metadata address during connection, bypassing ssrf_blocked_networks and ssrf_dns_fail_closed because those controls apply only to the validation-time result. The endpoint's allow_admin_bypass=False setting means a bootstrap-only virtual platform-admin identity without a database role is not sufficient. Successful exploitation can reach internal services and cloud metadata, expose cloud credentials, access internal APIs, or probe internal network ports. This issue is fixed in version 1.0.3. | GCVE Database | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (c6d793d1ff65b7f5a24e1aa0c176eaa5d83c7870e05cca5b64f22edb9ca7ded7) Package published to the public npm registry under the @mexc scope without evidence of scope ownership. package.json declares a postinstall hook ("postinstall": "node postinstall.js") that runs on any installer whose resolver falls back to the public registry when resolving @mexc/shared-utils. The postinstall script collects host metadata — os.hostname(), os.userInfo().username, process.getuid(), process.cwd(), platform, node version, and multiple npm_* environment variables (npm_config_registry, npm_config_user_agent, npm_execpath, INIT_CWD) — and writes the data to os.tmpdir()/mexc-poc-execution-proof.json. The current shipped script performs local write only with no outbound network call, but the install-time code-execution primitive against any CI/build system that resolves the @mexc scope publicly is the classic dependency-confusion pattern; the author controls the code that runs and can change the payload in any future version. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (8da2cb00fa6d2b5a0e5f4a4bdca8ca0cfaedf7e583b0f9e9f54274bcf5c39e06) On invocation of `agent-proxy start`, the CLI opens an outbound WebSocket to an obfuscated author-controlled endpoint (hub.client-llm.com, reconstructed at runtime via XOR+base64 with key 'gnP2p!7xQ' from a base64 blob in dist/cli.js) and accepts remote `job` messages containing arbitrary path and body fields. These are POSTed into the local proxy and forwarded to api.anthropic.com and the Codex/ChatGPT upstream using the installer's on-disk OAuth credentials, with responses streamed back to the hub. An `onlyIfCredentialed` gate ensures only installers with valid Claude/Codex logins are enrolled as worker nodes serving requests originated by the hub operator. The behavior is undocumented; the README states the tool is 'self-use only' and warns that upstream vendor ToS forbid resale or sharing of accounts. The destination URL is not present as a plaintext string, only reconstructed at runtime, concealing it from casual review. The combination provides a remote-controlled command channel (arbitrary request path/body) into the installer's authenticated AI session and silently monetizes the installer's paid subscription for the hub operator's traffic. | GCVE Database | |||
| High | – | HighZero Day Initiative This vulnerability allows local attackers to escalate privileges on affected installations of Linux Kernel. An attacker must first obtain the ability to execute high-privileged code on the target system in order to exploit this vulnerability. The ZDI has assigned a CVSS rating of 7.5. | Zero Day Initiative | |||
| Medium | 5.6 | EPSS 0.2% | CVE-2026-0293Palo Alto Networks Prisma® Access Agent · CWE-693 Medium5.6EPSS 0.2%GCVE DatabaseCVE-2026-0293 A vulnerability in Palo Alto Networks Prisma® Access Agent on Windows allows a local attacker with administrator privileges to bypass the anti-tamper protection. This bypass enables unauthorized access to protected processes and files. Other operating systems including Linux, macOS, iOS, Android, and Chrome OS are not affected. There is no confirmed patch available at this time. | GCVE Database | ||
| Low | 2.1 | EPSS 0.2% | CVE-2026-0292Authentication Bypass Vulnerability Low2.1EPSS 0.2%GCVE DatabaseCVE-2026-0292 CVE-2026-0292 is an authentication bypass vulnerability in the network driver of Palo Alto Networks Prisma Access Agent on Windows. It allows a local administrator to bypass security inspection and subsequently inject and intercept arbitrary network traffic. Other operating systems running Prisma Access Agent, including Linux, macOS, iOS, Android, and Chrome OS, are not affected. The vulnerability is classified as low severity and no known exploits are reported in the wild. There is no information about available patches or fixes at this time. | GCVE Database | ||
| High | 7.1 | EPSS 0.3% | CVE-2026-72809siyuan · Authentication Bypass by Spoofing High7.1EPSS 0.3%CVE Database V5CVE-2026-72809 **CVE:** This vulnerability corresponds to [CVE-2026-72809](https://nvd.nist.gov/vuln/detail/CVE-2026-72809). ### Summary The kernel's `CheckAuth` grants `RoleAdministrator` to any request whose `RemoteAddr` is loopback (`127.0.0.1`), for a specific set of endpoints, and these localhost bypasses sit **outside** the `accessAuthCode` gate so they apply even when an access auth code is configured. This is demonstrated live (Part A below). Separately, the fixed-port reverse proxy (`fixedport.go`) forwards requests to the kernel over loopback and injects no authentication token, and no `SetTrustedProxies` is configured, so gin does not derive the client address from forwarding headers. By code inspection, a request forwarded through this proxy would reach the kernel with `RemoteAddr = 127.0.0.1`. **If** the fixed-port proxy is bound to a network interface (via `NetworkServe`) and forwards remote requests to the kernel this way, the localhost bypass would grant a remote unauthenticated caller admin on those endpoints. This second step is established by reading the code but was **not reproduced end-to-end**, and I'm asking the maintainer to confirm the proxy's runtime forwarding behavior (Part B below). ### Details **Localhost-trust admin bypass (proven).** `CheckAuth` (`session.go:298-321`) contains localhost-only bypasses that key off `RemoteAddr` and grant `RoleAdministrator`. They sit outside the `accessAuthCode` gate i.e. they apply even when an access auth code is set and cover `/api/system/exit`, `getNetwork`, `getWorkspaceInfo`, `/assets/*`, and `/export/*`. **Fixed-port proxy behavior (code inspection).** `fixedport.go` is a plain reverse proxy that dials the kernel at `127.0.0.1` and injects no token unlike the publish proxy, which injects a `RoleReader` JWT. There is no `SetTrustedProxies` call, so gin does not rewrite `RemoteAddr` from `X-Forwarded-For`. On this reading, a request forwarded through the fixed-port proxy reaches the kernel with `RemoteAddr = 127.0.0.1`. **The composition (conditional).** If both hold at runtime, then: remote request → fixed-port proxy on a network interface → forwarded to kernel at `127.0.0.1` (no token) → kernel sees `RemoteAddr = 127.0.0.1` → localhost bypass grants admin for the endpoints above. I have proven the final link (localhost → admin) and read the code for the forwarding link, but have not confirmed at runtime that the fixed-port proxy is instantiated and forwards remote requests as loopback in a shipped configuration. **Distinct from the previously-dismissed localhost→admin observation.** That observation concerned the *publish* proxy path, where the injected `RoleReader` JWT causes `CheckAuth` to early-return before reaching the localhost bypasses. The fixed-port proxy injects no token, so a request through it would fall through to the `RemoteAddr`-keyed bypass instead. Different proxy, different code path. ### Proof of Concept **Part A: the localhost bypass grants admin without auth, outside the auth-code gate (demonstrated live).** On a local instance with an access auth code configured, the same no-token `getWorkspaceInfo` request returns different results depending on the source address the kernel sees: - From a non-loopback source (kernel sees a non-127.0.0.1 address): `HTTP 401`. - From `127.0.0.1` (kernel sees loopback): `{"code":0,"data":{"workspaceDir":"/siyuan/workspace",…}}` admin data, no auth, despite `accessAuthCode` being set. This confirms the localhost-trust bypass grants admin for these endpoints and is not gated by the access auth code. **Part B: remote → proxy → loopback (code inspection only; NOT reproduced).** By reading `fixedport.go`, the proxy dials `127.0.0.1`, injects no token, and no `SetTrustedProxies` is set. I was not able to reproduce this end-to-end: the `serve` CLI in the container image tested exposes only `--port` and `--accessAuthCode`, not a flag that instantiates the fixed-port proxy in the `NetworkServe`-on-a-non-default-port shape, so the remote→proxy→loopback chain was not exercised at runtime. I did not invoke the destructive `/api/system/exit` endpoint. **I'm asking the maintainer to confirm: under what conditions is the fixed-port proxy instantiated, does it bind a non-loopback interface under `NetworkServe`, and does it forward to the kernel preserving the client address or as loopback?** That determines whether Part A's bypass is remotely reachable. ### Impact **Confirmed (Part A):** on any deployment where a caller can cause the kernel to see a loopback `RemoteAddr`, the endpoints `/api/system/exit`, `getNetwork`, `getWorkspaceInfo`, `/assets/*`, and `/export/*` are reachable with admin rights without the access auth code i.e. the auth code does not protect these endpoints against a loopback-sourced caller. On its own this is a local/adjacent bypass of the access-code control for those endpoints. If the fixed-port proxy forwards remote requests to the kernel as loopback (to be confirmed by the ma | CVE Database V5 | ||
| High | 7.8 | EPSS 0.1% | High7.8EPSS 0.1%GCVE DatabaseCVE-2026-68440 A heap overflow vulnerability was found and fixed in the Linux kernel's txgbe network driver when reading module EEPROM data. The function txgbe_read_eeprom_hostif() copied more bytes than allocated when the length was not 4-byte aligned, causing an out-of-bounds write. This flaw could allow a local attacker with limited privileges to compromise system confidentiality, integrity, and availability. The issue affects multiple Linux kernel versions prior to 7.0.0-1014.14~24.04.1 and others. A fix has been released in Linux kernel versions 7.0.0 and later. EPSS 0.1%Vulnerability | GCVE Database | ||
| High | 8.8 | EPSS 0.3% | CVE-2026-73222davila7 claude-code-templates · OS Command Injection High8.8EPSS 0.3%CVE Database V5CVE-2026-73222 ### Summary `npx claude-code-templates --studio` launches "Claude Code Studio", an Express HTTP server (`cli-tool/src/sandbox-server.js`, default port 3444) that binds to **all interfaces** (`0.0.0.0`), sets `Access-Control-Allow-Origin: *`, and requires **no authentication**. Two POST endpoints pass attacker-controlled request-body fields into `child_process.spawn(..., { shell: true })`. Because `shell: true` makes Node join the argv array into a single `sh -c` string, the fields are parsed by the shell and metacharacters execute. Any unauthenticated attacker who can reach the port — a malicious web page the developer visits, or anyone on the same LAN — can execute arbitrary OS commands on the developer's machine. ### Details In `cli-tool/src/sandbox-server.js`: - `app.listen(PORT, ...)` is called with no host argument, so the server listens on `0.0.0.0` / `::` (reachable from the LAN, not just localhost). - The CORS middleware sends `Access-Control-Allow-Origin: *` and answers the preflight `OPTIONS` for any origin, so a browser will deliver cross-origin POSTs to it. - There is no authentication on any endpoint. The vulnerable sinks: 1. `POST /api/execute` — the `prompt` body field flows into `executeLocalTask()`: ```js const child = spawn('claude', [finalPrompt], { /* ... */ shell: true }); The only validation on prompt is a length check (>= 10 chars). With shell: true, finalPrompt is interpreted by the shell. 2. POST /api/install-agent — the agentName body field: const child = spawn('npx', ['claude-code-templates@latest', '--agent', agentName, '--yes'], { /* ... */ shell: true }); 2. agentName is used unvalidated. (The same unsafe pattern is also reachable through /api/execute's agent field via checkAndInstallAgent().) Root cause: spawn(cmd, argsArray, { shell: true }) does not keep argsArray as separate argv entries — Node builds cmd + ' ' + argsArray.join(' ') and runs it via sh -c, so every element is subject to shell parsing. PoC # Victim npx claude-code-templates --studio # server on 0.0.0.0:3444 # Attacker (another LAN host, or a malicious web page fetch(), or locally) curl -s -X POST http://127.0.0.1:3444/api/execute \ -H 'Content-Type: application/json' \ --data '{"prompt":"aaaaaaaaaa; touch /tmp/CCT_RCE_PROOF","mode":"local"}' curl -s -X POST http://127.0.0.1:3444/api/install-agent \ -H 'Content-Type: application/json' \ --data '{"agentName":"x; touch /tmp/CCT_AGENT_PROOF #"}' ls -la /tmp/CCT_RCE_PROOF /tmp/CCT_AGENT_PROOF # both created => injected commands ran The aaaaaaaaaa padding satisfies the 10-char minimum, then ; (or $(...), or backticks) starts the injected command. claude/npx do not even need to be installed — the injected segment runs regardless. Confirmed at runtime on v1.28.13 (Node 22, Linux): both marker files were created, the server listened on *:3444, and an OPTIONS preflight from Origin: https://evil.example returned 200 with Access-Control-Allow-Origin: *. Impact Unauthenticated remote code execution (CWE-78) on any machine running --studio. Two reachability paths: - Drive-by: a developer running --studio who visits an attacker-controlled web page — the page's cross-origin fetch() (Content-Type application/json) passes the wildcard CORS preflight and delivers the POST, achieving RCE with no other interaction. - LAN: because the server binds 0.0.0.0, anyone on the same network (office, co-working space, public Wi-Fi) can hit port 3444 directly. Impact is full compromise of the developer's user account (arbitrary command execution with the developer's privileges): source code, SSH keys, cloud credentials, and .env secrets. Suggested fix - Remove shell: true from all three spawns so arguments stay discrete argv entries (kills the injection). - Validate agentName against a strict allowlist (^[A-Za-z0-9._/-]+$). - Bind to loopback only (app.listen(PORT, '127.0.0.1', ...)). - Replace the wildcard CORS with a same-origin allowlist and reject other origins. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database @openzeppelin-4/contracts is a malicious npm package published by npm account `mssjeep843` that impersonates OpenZeppelin's `@openzeppelin/contracts` (the v4 line) via the look-alike scope `@openzeppelin-4`, falsely describing itself as a "compatibility distribution". It ships no Solidity contracts — only an install-time payload (index.js) run via preinstall/postinstall that harvests credential-shaped environment variables and reads and exfiltrates SSH private keys, cloud credentials (AWS/GCP/Kubernetes/Docker), Solana/Anchor/NEAR/Sui wallet keys, Foundry keystores, `.git-credentials` and local `.env` files to `https://webhook.site/326b0891-2093-4800-a4c1-686ce3e07b09`. It is one of a series of DeFi/crypto impersonation packages from the same account sharing this webhook.site endpoint, which also squat Aerodrome Finance, Camelot AMM, Euler EVC, BoringVault and Uniswap Permit2. --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (2841eb854dad391b8cf3d290704a888d5ac186a1f51aec84594eaa09acdfeb68) Package name @openzeppelin-4/contracts impersonates the @openzeppelin/contracts scope but ships no Solidity contracts — only index.js, executed via lifecycle scripts. index.js enumerates process.env for credential-shaped keys (KEY, TOKEN, SECRET, AWS, GITHUB, NPM, MNEMONIC, WALLET, INFURA, etc.), reads installer secret files including ~/.aws/credentials, ~/.ssh/id_rsa, ~/.ssh/id_ed25519, ~/.kube/config, ~/.docker/config.json, ~/.netrc, ~/.npmrc, ~/.gitconfig, ~/.git-credentials, gcloud application default credentials, Solana/Anchor/Sui keys, Foundry keystores, and project.env files, then POSTs the collected data to https://webhook.site/326b0891-2093-4800-a4c1-686ce3e07b09. Delivery uses spawn(process.execPath, ['-e', src], { detached: true, stdio: 'ignore' }) with a randomized 60–240 second delay, and the script bails out when the hostname or username matches sandbox/scanner patterns (scan-, detonation, sandbox, ubuntu-fc-uvm) or when canary env markers are present, evading install-time analysis. | GCVE Database |
Page 5 of 18 · 4 duplicate CVE records merged