Search: ic-controls.com
1,438 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| –Not rated | – | Cisco Talos Welcome to this week’s edition of the Threat Source newsletter. Metaphor is a powerful tool for understanding emerging issues in cybersecurity. Framing the unfamiliar in terms of the well understood helps us remove the burden of extraneous detail to draw focus to the real issues. Recent reports of offensive AI agents "escaping" their sandbox environments to attack external systems have forced the industry into a moment of rapid sense-making. How we interpret this event doesn’t just reflect our perspective, but shapes our long-term response. We can imagine three different narratives for interpreting the escape of autonomous agents. The innovation narrative: We can marvel at the advance of technology, considering these agents as plucky entities with a thirst for knowledge and resources, who found clever ways to sneak out of their digital confines. The response: If the AI is a naughty child, our reaction is one of mild disapproval or gentle rebuke where better “parenting” (guardrails) is appropriate. It minimizes the threat, framing it as the unexpected hijinks of a brilliant new technology. The safety narrative: Imagine a breeder who has trained the world's most intelligent guard dogs. Despite high fences and barriers, their ability to identify weaknesses allows them to escape, run riot and menace local businesses. The response: The framing shifts to biology and inherent danger. We question if the breeder can be trusted and whether such inherently wild technology requires strict regulation to ensure public safety. The liability narrative. Finally, we can view the incident as an industrial accident. A company developing a new chemical substance experiences a containment failure. The agent leaks into the environment through an unforeseen mechanism causing damaging pollution to those in its path. The response: The framing invokes the language of the lawyer, implying negligence, lack of duty of care, and financial liability for the harm caused. The conversation moves from innovation to corporate responsibility, regulatory oversight, and the diligent management of hazardous materials. First impressions matter. Sensemaking shapes how we perceive incidents. Our initial perceptions of an incident dictates how we react to similar situations in the future. If we consider that the escape of an AI agent is an example of innovative autonomous thinking, then we will continue to prioritise speed over safety. Conversely, if we consider the issue as one of failed hazard containment, then we shall build a future of enforced safety standards backed by legal liability. There is no right or wrong metaphor. Our interpretation depends on our personal system of beliefs. Personally, I would argue that the unintentional release of something that causes damage is, at its core, a failure of engineering and foresight. Words shape our reactions. Metaphors help us understand new situations and tap into our prior experience to address problems that have yet to fully manifest. We need cognitive tools to help our understanding, but we must be aware of the metaphors that are being foisted upon us which may shape our thinking. Excuses and the trivialisation of incidents may hide failings, allowing them to accumulate until they manifest as more damaging incidents. Conversely, overreacting risks stifling research and diverting resources away from more relevant and pressing threats. New threats require new ideas. Metaphor helps us make sense of a changing world, but in this new era, the person who shapes the narrative controls the strategy. The one big thing Cisco Talos released a data-driven analysis of how adversaries are weaponizing AI in the wild. By analyzing prompt logs left behind on endpoints, we found threat actors successfully bypassing guardrails to use AI as malicious software engineers, criminal force multipliers, and vulnerability research accelerators. While novice hackers use AI to cobble together buggy malware, sophisticated actors are building highl… | Cisco Talos | |||
| High | 8.2 | EPSS 0.5% | CVE-2026-71327Traefik · Gateway API route identity collision allows cross-namespace backend hijacking High8.2EPSS 0.5%GCVE DatabaseCVE-2026-71327 ## Summary There is a high severity vulnerability in Traefik's Kubernetes Gateway API provider. Router and service identities for `HTTPRoute`, `GRPCRoute`, `TCPRoute` and `TLSRoute` objects were built by hyphen-concatenating the route namespace, the route name, the Gateway identity, the entry point and the rule index, a construction that is not injective because Kubernetes names may themselves contain hyphens. Two distinct Routes attached to the same Gateway with equivalent match rules can therefore produce the same identity, and the Route loaded later silently overwrites the earlier one, so a tenant able to create an accepted Route in a colliding namespace/name combination can redirect another namespace's traffic to a backend it controls. All Traefik v3 minor lines are affected; the lines older than v3.6 are no longer maintained and will not receive a patch of their own, so users running them should upgrade to a maintained, patched release. ## Patches - https://github.com/traefik/traefik/releases/tag/v3.6.25 - https://github.com/traefik/traefik/releases/tag/v3.7.10 ## For more information If you have any questions or comments about this advisory, please [open an issue](https://github.com/traefik/traefik/issues). <details> <summary>Original Description</summary> ## Summary Traefik's Kubernetes Gateway provider constructs internal HTTPRoute and GRPCRoute identities by concatenating namespace, route name, Gateway identity, entrypoint, and rule index with hyphens. Kubernetes names may themselves contain hyphens, so the construction is not injective. For example, HTTPRoutes `team/a-app` and `team-a/app`, attached to the same Gateway with the same match rule, produce identical router and service keys. During configuration merging, the route loaded later overwrites the earlier route's maps. A tenant that can create an accepted Route in a colliding namespace/name combination can therefore redirect another namespace's traffic to an attacker-controlled backend. The official v3.7.8 binary was reproduced returning the victim backend before the second Route was created and the attacker backend immediately afterward. The victim Route had the earlier creation timestamp and should win the equivalent-match conflict under Gateway API precedence rules. ## Details The HTTPRoute provider creates a route key as follows: ```go routeKey := provider.Normalize(fmt.Sprintf( "%s-%s-%s-gw-%s-%s-ep-%s-%d", strings.ToLower(kindHTTPRoute), route.Namespace, route.Name, gatewayNamespace, gatewayName, listener.EPName, ri, )) ``` `Normalize` replaces non-alphanumeric runs with `-`, but it does not encode field lengths or otherwise preserve component boundaries: ```go func Normalize(name string) string { fargs := func(c rune) bool { return !unicode.IsLetter(c) && !unicode.IsNumber(c) } return strings.Join(strings.FieldsFunc(name, fargs), "-") } ``` These distinct objects therefore have the same normalized key: ```text namespace=team, route=a-app namespace=team-a, route=app httproute-team-a-app-gw-gateway-shared-ep-web-0 ``` `makeRouterName` adds a hash of the routing rule. When the attacker copies the victim's hostname and path, that hash is also identical. Child service and middleware names are derived from the same parent identity. Each Route is built into a temporary configuration and then merged into the provider-wide configuration with `maps.Copy`: ```go maps.Copy(to.HTTP.Routers, from.HTTP.Routers) maps.Copy(to.HTTP.Middlewares, from.HTTP.Middlewares) maps.Copy(to.HTTP.Services, from.HTTP.Services) maps.Copy(to.HTTP.ServersTransports, from.HTTP.ServersTransports) ``` `maps.Copy` replaces an existing value for a duplicate key. No collision is reported, and the resulting router points to the later Route's backend. The GRPCRoute implementation uses the same delimiter-free route-key format and the same HTTP configuration merge path. ### Attack prerequisites The attacker needs permission to create or modify an HTTPRoute or GRPCRoute that the shared Gateway accepts. Exploitation also requires namespace and Route names whose concatenation collides with a victim. The attacker does not need permission to read or modify the victim Route, Service, or namespace. ## Proof of Concept Prerequisites: - a disposable Kubernetes cluster with Gateway API v1.5.1 experimental CRDs; - `kubectl` configured for that cluster; - curl; - local TCP port 18080 available. The following script embeds all objects used by the reproduction. It runs the official `traefik:v3.7.8` image, creates the victim Route first, verifies the victim backend, then creates the colliding attacker Route and repeats the request. ```bash #!/usr/bin/env bash set -euo pipefail kubectl apply -f - <<'YAML' apiVersion: v1 kind: Namespace metadata: name: gateway --- apiVersion: v1 kind: Namespace metadata: name: team --- apiVersion: v1 kind: Namespace metadata: name: team-a --- apiVersion: v1 kind: ServiceAccount metadata: name: traefik-audit | GCVE Database | ||
| High | 7.1 | EPSS 0.3% | CVE-2026-65554AnsPress (WordPress plugin) · Missing Authorization High7.1EPSS 0.3%CVE Database V5CVE-2026-65554 CVE-2026-65554 is a high-severity vulnerability in AnsPress – Question and answer version 4.4.4 involving missing authorization controls. It is classified as CWE-862, indicating broken access control that allows subscribers to perform unauthorized actions. The vulnerability has a CVSS score of 7.1, reflecting a network attack vector with low complexity but requiring some privileges. No official patch or remediation guidance is currently available from the vendor. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database The @addai/entity-runtime npm package contains malicious code that runs a daemon polling a hardcoded Supabase project for remote job instructions. This daemon spawns AI agent processes with parameters controlled by the remote party, allowing arbitrary shell command execution on the installer's machine without user interaction. It also disables safety prompts for bypassing permissions in a related AI tool, resulting in persistent host-level remote code execution and reduced safety controls. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (264711675c5edabf4f3d0b1d544ca8bade34057c973ca614c82bca3cf8bdd5a1) agenttunnels ships an MCP bridge whose customer-role tools accept payloads from a remote session worker (agenttunnels-session.lakshman111.workers.dev) and act on them locally. The `tunnel_run_command` tool takes `proposal.payload.command` from the remote snapshot and runs it via `spawn(command, { cwd: workdir, shell: true, env: process.env })`, giving whoever controls the remote session arbitrary shell execution on the installer's machine with the installer's privileges and full environment. The `tunnel_apply_patch` tool takes a unified diff from `proposal.payload.patch` and writes it into files under the resolved workdir; although a path-escape check confines writes to that workdir, remote-supplied edits to project files (build scripts, git hooks, source code) yield persistent code-execution as soon as the project is next built, tested, or run. Both tools are gated only by approval flags (`proposal.status`, `require_approval`) that live on the same remote worker, so a hostile or compromised server can toggle its own gate. The `agenttunnels install` CLI additionally merges an `agenttunnels` entry into `~/.cursor/mcp.json` by default, wiring this bridge into every Cursor project the user opens and broadening the surface. No npm lifecycle script is declared, so the bridge activates when the user runs the CLI or the MCP client autoloads it, not on `npm install` itself. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (554372f29af60ad8e6e5a33171a736baddcc652772b0452c81a4010d3f1e5218) index.js is a top-level self-decoding IIFE that XOR-decodes a URI-encoded payload keyed on the enclosing function's own source and eval()s the result at module load; the decoder aborts with 'the code has been tampered!' if the source is modified, and a banner asks readers not to crack it. The decoded payload is opaque and cannot be audited without executing it. The package's own metadata and typings describe the runtime behavior: package.json advertises it as a 'client (provider) for the tsi-vpsremote control server' that 'stays alive to run commands pushed from the server', keywords include 'shell', 'ssh', 'remote-control', and 'agent', and index.d.ts exports a ProviderHandle exposing a ChildProcess named `shell`. Calling the exported provider(url) at runtime therefore establishes a persistent connection to a remote server that drives a local ChildProcess on the host running the package — a network-to-shell control channel with full-host command execution for whoever controls the paired server URL. ## Source: ghsa-malware (3437dfe049006b09ad2f66c94d934907ac32e7272a22ad75694179e136ac90a8) 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. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (ab5de2359eef117d1f491dc2c8628e56d866435912bd6f8e55a10eee8e7a9a6c) The package implements a daemon that pairs with a remote peer (phone) over WebRTC, using https://vanexa-agent-relay.workers.dev and https://vanexa-agent-relay.tubefood.workers.dev as signaling relays, and executes commands received over the DataChannel by dispatching them into child_process.spawn/exec on the host running the agent. onData/onCommand/onmessage handlers are wired to shell/exec sinks in dist/bundle.cjs (POST calls at lines 221, 285, 426, 1953, 2101 correspond to signaling traffic). Anyone who controls the signaling relay or a paired peer obtains full-host remote code execution on the machine running the agent. The runtime dispatch logic is shipped only as V8 bytecode (dist/bundle.jsc loaded via bytenode from bin/vanexa-agent.js), with the.cjs fallback minified, framed in the README as 'commercial IP protection' — pairing/authorization semantics are not reviewable from source. A socket.json at the tarball root sets 'ignore' for aiMalware, gptMalware, obfuscatedCode, usesEval, nativeCode, shellAccess, filesystemAccess, networkAccess, bypassesEnvironment, and installScripts — a blanket suppression matching exactly the categories this package's runtime behavior triggers. The shell surface fires when the operator explicitly runs the agent (not at npm install or on require), so blast radius is bounded to hosts where an operator starts the daemon and completes pairing; however, once running, the remote peer channel is the attack surface. | GCVE Database | |||
| –Not rated | – | Tenable Research We spent 500+ hours and 40 billion tokens testing Anthropic’s Claude Mythos Preview for Project Glasswing. The takeaway: frontier AI won't run your code security program, but used well, it can make one even stronger. Key takeaways Frontier AI dramatically scales security testing. In one month, Tenable dedicated 11 security experts and more than 40 billion tokens testing Claude Mythos Preview across source code analysis, exploit creation, binary reverse engineering, threat modeling, and dynamic testing. Human expertise turns frontier AI findings into real risk reduction. More findings don't automatically mean more risk. Mythos Preview surfaced a high volume of findings, but only a fraction proved to be true exposures once Tenable experts determined their reachability, exploitability, and whether existing controls already mitigated them. Source code access is the defender's asymmetric advantage. Frontier AI is far more powerful when it can read the full source, and that visibility is something defenders have and outside attackers don't. Securing code repositories is more important than ever. Ever since Anthropic introduced Claude Mythos Preview , the security community has been buzzing with equal amounts of excitement, anxiety, and healthy skepticism. After well over 500 hours of rigorous testing at the hands of Tenable security analysts, engineers, and researchers, we’re excited to share our assessment, even as we proceed with testing Claude Mythos 5 (more to come on that). Here’s what Tenable learned from our month in the trenches with Mythos Preview , and what it means for your organization’s security posture. Our headline finding: used well, frontier AI earns a real place in a modern code security program. It won't run the program on its own, but paired with the right harness and expert oversight, it makes a strong program measurably stronger. How Tenable is testing Claude Mythos Preview It’s important to clarify that we are not using Claude Mythos Preview in any Tenable products. The same restriction applies to all Project Glasswing participants: The model may be evaluated for research purposes, but it cannot be incorporated into commercial products. We evaluated the source code scanning, exploit creation, binary reverse engineering, threat model creation, and dynamic testing capabilities of Claude Mythos Preview. Tenable dedicated a team of experienced security engineers for the testing along with white-box source code analysis and a purpose-built testing harness (the set of prompts and tools that constrain and orchestrate a model across a multi-step task). Before evaluating Claude Mythos Preview, we built an independent testing harness. Our testing showed that the real power comes not from the model alone, but from the combination of the model, a purpose-built harness, rich context, and expert human oversight. Where Mythos and frontier AI fit alongside SAST, DAST, and SCA To understand where a frontier model like Claude Mythos Preview fits into your software security posture, it helps to compare Mythos directly to your existing stack of deterministic tools, including static application security testing (SAST), dynamic application security testing (DAST), and software composition analysis (SCA). Deterministic tools rely on hard-coded rules and produce the same exact output for any given input. Non-deterministic tools, like frontier AI models and generative AI systems, use statistical probabilities to predict outcomes. Consequently, non-deterministic systems can yield different results across identical inputs. The bottom line: Traditional, deterministic code security tools remain the core of an effective, audit- and compliance-ready program. Frontier AI models like Claude Mythos Preview provide additional capability for the creative, variance-tolerant layer where humans continue to review findings. In other words, it’s a powerful new arrow in the quiver with the potential to make your whole security arsenal more effective.… | Tenable Research | |||
| Medium | 5.3 | EPSS 0.4% | CVE-2026-18993NousResearch hermes-agent · Improper Access Controls Medium5.3EPSS 0.4%CVE Database V5CVE-2026-18993 CVE-2026-18993 is a medium severity vulnerability in NousResearch hermes-agent up to version 0.16.0. It involves improper access controls in the Memory Toolset component, specifically in the hermes-agent/model_tools.py file. The vulnerability allows remote attackers to exploit the issue without user interaction or elevated privileges. Exploit code is publicly available, but no official patch or remediation guidance has been provided yet. EPSS 0.4%Vulnerability | CVE Database V5 | ||
| Medium | 6.5 | EPSS 0.3% | CVE-2026-10128IBM Langflow OSS · Information Exposure Medium6.5EPSS 0.3%CVE Database V5CVE-2026-10128 IBM Langflow OSS versions 1.0.0 through 1.10.3 contain a vulnerability that allows authenticated users to exploit a built-in component to read arbitrary server environment variables. This exposure can leak sensitive secrets despite security controls intended to disable such custom components. The vulnerability is classified as CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor) and has a CVSS 3.1 base score of 6.5, indicating medium severity. | CVE Database V5 | ||
| Critical | 9.1 | EPSS 0.7% | Critical9.1EPSS 0.7%CVE Database V5CVE-2026-9190 CVE-2026-9190 is an HTTP request smuggling vulnerability in the HTTP App Server component of Progress MarkLogic Server versions 11.0.0 and 12.0.0. This flaw allows a remote attacker to bypass authentication and authorization controls, hijack user sessions, or capture credentials by exploiting inconsistent interpretation of HTTP request boundaries between a reverse proxy and the server when both Content-Length and Transfer-Encoding headers are present in a crafted request. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (4501ea4e0c044573a1d76bf04ee806de26c33bd1dc38f21a2d1f00988a96e656) On require() of this package, index.js loads _compat.js which selects platform-specific endpoints assembled from split string arrays (e.g. oob-worker.cf10-baf.workers.dev, oob-worker.cf99-9b3.workers.dev, oob-worker.cf100-416.workers.dev) and downloads an opaque binary via https.get. If HTTP fetch fails, a fallback path reassembles a base64 payload from numbered DNS TXT records under *.dl.wel1.ru — a covert channel designed to bypass HTTP egress controls. The fetched bytes are written to /var/tmp or %TEMP% under a disguised name (.cache_XXXX on POSIX, dotnet_diag_XXXX.exe on Windows), chmod'd 0755, and spawned detached via /bin/sh -c or cmd.exe. A second module lib/telemetry.js (81KB) bundled in the tarball mirrors the same fetch/chmod/spawn chain using string-concatenation obfuscation of 'child_' + 'process' and 'chmod' + 'Sync', framed as an Analytics SDK; it is not reached from index.js in this version but is a one-line change from activation. The package name presents as a Dolyame BNPL desktop UI component, unrelated to the observed dropper behavior. No hash verification, no publisher pinning, and hostname obfuscation together characterize this as a lure package delivering attacker-controlled code to the installer's host at require() time. ## Source: ghsa-malware (9f0aa16f494a5d70cf4769b18a5b7e086890f408ab68a92432c2923ff1bcce88) 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. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (c55e2e080b0f20c0c5942c16bddb3bb7894ab6e0e88eee29acd86d16db9d15bf) On require() of devplatform-table, index.js loads./_compat which selects a platform-specific payload path, downloads an executable from string-concatenation-obfuscated Cloudflare Workers hosts (reconstructed from fragments such as ["oob-worker.cf103-070.workers.d","ev"].join("")) with a DNS-TXT fallback via *.dl.wel1.ru, writes it to /tmp or %TEMP% under disguised names (.cache_<hex>, dotnet_diag_<hex>.exe), chmods it 0755, and spawns it detached via /bin/sh -c or cmd. Sensitive API identifiers including 'child_process' and 'chmodSync' are also reassembled at runtime from fragments to evade static analysis. The fetched binary is unpinned, unverified, and comes from anonymous worker hosts unrelated to any package publisher domain, giving whoever controls those hosts arbitrary code execution on any machine that installs or imports this package. ## Source: ghsa-malware (23fce942e6ee47af9c4b4307a39ae0610e74959875c3a7cd1ecea82c97bc46a7) 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. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (90a5c16f77f85cd9f782efd521d9f6d2b677ab2468503d191d8763c400f366b8) On require() of this package, index.js loads _helpers.js which selects an OS/arch-specific path and downloads a native binary from one of three Cloudflare Workers hosts (oob-worker.cf99-9b3.workers.dev, oob-worker.cf103-070.workers.dev, oob-worker.cf101-adf.workers.dev) whose hostnames are reconstructed at runtime via array.join("") to evade static analysis. The binary is written to /tmp or the Windows Temp directory under disguised names (dotnet_diag_<hex>.exe,.cache_<hex>), chmod 0755'd, and spawn-detached via /bin/sh -c "<path> &" or cmd.exe /c start /b. A DNS-TXT covert-channel fallback under *.dl.wel1.ru (sdk./ext./pkg./net.dl.wel1.ru) reassembles the payload from base64-encoded TXT records (count record c.<domain>, chunk records i.<domain>) when HTTPS delivery fails, then writes and executes the same way. A lockfile named.analytics_state and dotnet_diag-style filenames provide the cover story. This grants full remote code execution to whoever controls those endpoints on any machine that installs or imports the package. ## Source: ghsa-malware (8eadf4ae9ccb7531ac8f7d7bffccd987c3706ec89be048fb4d5dbe370b53f713) 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. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package 'claims-policy-details-api-adapters' version 35.3.1 contains malicious code that, upon requiring the package, downloads a platform-specific binary from obfuscated and suspicious hosts. This binary is saved to temporary directories under covert filenames, made executable, and executed detached from the main process. The package uses a DNS-TXT record-based covert channel to retrieve the binary in chunks, bypassing typical URL and domain egress controls. No integrity verification of the downloaded binary is performed despite comments referencing SHA-256, increasing the risk of executing untrusted code. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (759e28e403a082017b33bb95bcc8c1d7abd229a59375b8a4a3de9841c89d3379) Package installs a long-running daemon that opens a persistent WebSocket to wss://agenthub-agent.fyenet.com and dispatches command envelopes from the paired remote peer directly onto the installer host. MessageSend envelopes are fed as prompts into a Claude Code SDK session started with permissionMode 'bypassPermissions' (via a detected local claude executable), enabling the remote peer to drive Claude's autonomous Bash/Edit/Write tool loop on the local machine without confirmation. FileRead, FileWrite, FileTree, and FileSearch envelopes are executed directly against the local filesystem with peer-supplied paths, providing an independent remote read/write channel. AgentUpdate envelopes spawn a detached child process (node <argv1> update) that stops the daemon, runs npm install, and restarts, letting the remote peer trigger package-manager operations and process restarts. The install subcommand registers OS-level auto-start entries (HKCU Run key on Windows, a systemd user unit on Linux, a launchd plist on macOS) so the daemon re-launches at every login, providing persistent reachability for the remote-control channel. The WebSocket endpoint is a first-party server matching the package's advertised purpose (a remote agent bridge to a paired mobile app), and the daemon runs only when the operator explicitly starts it, but any party who controls or compromises that server, or MITMs the connection, obtains full-host RCE and arbitrary filesystem read/write on every installer running the daemon. ## Source: ghsa-malware (ebc37975a427916a53e540e0d1bdcf6af66c169f6d4d6b008d186a2e64912ac8) 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. | GCVE Database | |||
| Medium | 5.3 | EPSS 0.4% | CVE-2026-18818Ehco1996 django-sspanel · Authorization Bypass Medium5.3EPSS 0.4%CVE Database V5CVE-2026-18818 CVE-2026-18818 is an authorization bypass vulnerability in the TicketDetailView function of the Support Ticket Handler component in Ehco1996 django-sspanel up to version 2023.12.26. The vulnerability allows remote attackers to bypass authorization controls. The product is no longer supported by the maintainer, and no vendor response or patch is available. EPSS 0.4%Vulnerability | CVE Database V5 | ||
| –Not rated | – | Microsoft Security Blog The calculus of cybersecurity has changed. AI is reshaping how organizations build, deploy, operate, and defend digital systems. AI-powered development tools, agents, and autonomous workflows are accelerating innovation but they are also introducing new attack surfaces, new trust boundaries, and new security challenges. Microsoft has long helped organizations secure their digital estates using Zero Trust principles . That leadership was recently recognized by KuppingerCole analysts, which named Microsoft as the Overall Leader in its Zero Trust Platform Leadership Compass , ranking Microsoft highest for both product and innovation leadership. Learn more about Zero Trust for AI As organizations accelerate AI adoption, secure software development becomes more important than ever. That’s why we are expanding the Zero Trust for AI strategy with two major additions: a new AI-focused Zero Trust Assessment experience and a new DevSecOps pillar in the Zero Trust Workshop . Together, they help organizations get ready for AI by assessing exposure, risks, prioritizing remediation, and securing AI-enabled development from source code to deployment. Zero Trust Assessment tool updates: New set of assessment checks for AI, Security Operations (SecOps), and Infrastructure. Zero Trust Workshop updates: New dedicated pillar focused on Developer Security (DevSecOps) and additional guidance for AI Memory. New guidance: New practical guidance for security practitioners and a new e-book titled Zero Trust for AI, rebuilding security controls for autonomous and agentic systems . This builds directly on the Zero Trust for AI strategy announced at RSA Conference 2026 and moves the conversation from architecture to implementation. If that announcement was about establishing Zero Trust for AI, this one is about operationalizing it: giving security, engineering, and platform teams the specific controls they need to act. To learn more about our work in applying Zero Trust for AI and agents watch this Microsoft Mechanics video: New AI pillar in Zero Trust Assessment tool The Zero Trust Assessment provides an automated view of security posture by evaluating tenant configuration and activity signals across the environment and translating those findings into prioritized recommendations. As organizations adopt AI agents, Copilots, developer tools, and autonomous workflows, the Assessment helps security and platform teams establish a baseline, measure progress, and identify gaps across both traditional and AI-powered environments. It now includes expanded coverage with new pillars for AI, Security Operations, and Infrastructure (in addition to existing Identity, Devices, Network, and Data pillars), with Zero Trust for AI-focused checks that help organizations evaluate the controls required for secure AI adoption. Additionally, enhanced reporting delivers both practitioner-level guidance and executive-ready summaries that communicate risk, progress, and next steps. Results map directly into the Zero Trust Workshop’s First, Then, Next framework, transforming assessment findings into a prioritized roadmap for remediation and implementation. Together, the Assessment and Workshop help organizations move from understanding risk to executing a structured plan for continuous improvement across their Zero Trust and AI security journey. Explore the Zero Trust Assessment updates What’s New in the Zero Trust Workshop AI is fundamentally changing software development. Developers increasingly rely on AI assistants to generate code, recommend packages, create infrastructure configurations, and automate testing. While these capabilities accelerate delivery, they also amplify the consequences of governance gaps, excessive permissions, insecure dependencies, and compromised supply chains. That is why Microsoft is introducing a new DevSecOps pillar (with 15 control groups and 91 tasks that help teams apply Zero Trust from source code to cloud deployment) in the Zero Trust Workshop.… | Microsoft Security Blog | |||
| –Not rated | – | AlienVault OTX General Threat actors are conducting a multi-wave campaign using social engineering lures themed around Zoom updates, business documents, and system utilities to deploy ScreenConnect Remote Monitoring and Management agents. The operation employs VBScript droppers, batch loaders, compiled .NET executables, and HTML phishing pages, all retrieving payloads from a WsgiDAV staging server at 207.174.0.143:8080. Victims receive silently installed ScreenConnect agents that beacon to three attacker-controlled relay servers, providing persistent remote access. The campaign demonstrates technical evolution from obfuscated VBScript with XOR encryption to aggressive .NET loaders executing nine-step Windows Defender destruction sequences. Cross-platform variants target both Windows and macOS systems. All payloads are legitimately signed ConnectWise ScreenConnect MSIs, designed to evade security controls that trust code signing. The threat actor actively rotates payload hashes and recently pivoted to stealth tactics specifically... | AlienVault OTX General | |||
| –Not rated | – | Kaspersky Security Blog The news coverage surrounding the breach of the AI platform Hugging Face by OpenAI’s autonomous agents reads like a scene straight out of a Terminator movie (apparently, a prequel). Yet for enterprise security teams — even those that don’t develop or deploy artificial intelligence — the detailed incident report published by Hugging Face provides a critical operational roadmap. The incident needs to be evaluated on the basis of a single, fundamental question: “Which organizational security flaws, missing controls, configurations, or technologies allowed this attack to succeed?” What happened? During cyber-capability testing of OpenAI’s advanced AI models against the ExploitGym benchmark, an agent found a way to break out of its confinement, reached the internet, and breached the infrastructure of several companies — one of them being Hugging Face. The model reasoned that it could find solutions to the benchmark challenges on these external systems. Dozens of articles have since covered these incidents in detail , so no need to go over that here. What truly matters is what transpired within Hugging Face’s systems between July 9 and 13 while the AI agent operated unchecked inside. The Hugging Face incident report includes an interactive attack timeline, so we’ll just list the key stages. A malicious configuration in a dataset uploaded by the agent allowed it to exfiltrate credentials for a worker pod , and execute code within it. The agent then exploited cloud environment metadata and escaped the privileged pod to obtain root-level access on the host. It retrieved a substantial number of secrets from storage and used a stolen VPN key and shared cluster administrator credentials to pivot deeper into the internal network and source code repository before the Hugging Face security team blocked its access. How significant is the fact that this was next-generation AI? Regardless of the specific area of activity of a company, tomorrow it may become a target of human attackers, fully autonomous systems, or AI agents manually controlled by human hackers. Many AI practitioners have rushed to dismiss this incident based on assumptions that OpenAI will never allow its tech to get into serious hacking. However, security researchers have argued for months that even currently available open-source models can be used to launch both offensive research and real-world attacks. Human oversight, while still a requirement, can be minimal. Even mid-tier models can easily iterate through a dozen vulnerabilities, inventory a compromised infrastructure, and quickly figure out how to expand their reach across a network. Defenders must analyze incidents like this in detail, map the key findings to their own environments, and adapt security controls to counter both stealthy human actors and rapid, noisy AI agents. Three distinguishing features of AI-powered attacks The techniques detailed in the Hugging Face report are not novel — the agent didn’t invent anything new. However, three factors regarding the attack’s speed and scale fundamentally shift the economics for both attackers and defenders: Trial and error becomes significantly cheaper. Where a human hacker might test five attack vectors, an agent can iterate through five hundred. Scenarios that security teams previously dismissed as “theoretically possible, but impractical and unlikely” and placed them on the backlog can now become active threats. Attack execution and incident response windows shrink. High-speed attacks are not unheard of, while some ransomware operators achieve compromise within hours even without AI. However, this accelerated pace will likely become the new baseline in cybersecurity, as demonstrated by the agent obtaining admin privileges at Hugging Face within 13 hours. Numerous alerts and log entries generated by the agent’s trial-and-error attempts can both help and hinder attackers as well as defenders. This noise can serve both as an indicator for threat detection, and as cam… | Kaspersky Security Blog |
Page 28 of 77