Search: discovery.com

A flaw has been found in Fast FAC1203R Gigabit Edition 2.0.4. Affected by this issue is the function copy_msg_element of the component Device Discovery Service. Executing a manipulation can lead to stack-based buffer overflow. The attack can be executed remotely. The exploit has been published and may be used. The vendor was contacted early about this disclosure but did not respond in any way.

Shadow IT refers to hardware, software, and services operating outside the visibility or approval of IT and security teams, creating security blind spots. Wazuh is an open source security platform that helps organizations reduce these visibility gaps by collecting detailed inventory data from monitored endpoints and correlating it with vulnerability and policy information. It supports agent-based and agentless monitoring, including for devices that cannot run agents. Wazuh provides centralized dashboards for visibility into unmanaged endpoints, unauthorized software, browser extensions, and services. It also enables detection and removal of unauthorized applications through custom rules and active response scripts. This approach addresses the limitations of network discovery scans, which only identify devices responding during scan windows, leaving many assets invisible. Overall, Wazuh helps organizations improve asset visibility and reduce risks associated with shadow IT.

Picus Labs analyzed 338 million attack simulations in production environments, finding that perimeter defenses block 69% of attacks, while post-compromise blocking effectiveness drops to 37%. The research highlights challenges in detecting quiet discovery and collection actions, with only 10% blocked, and low alerting rates despite high logging. Different attack tools show varying detection rates depending on the method used. This data provides insights into the effectiveness of perimeter and post-compromise defenses and detection engineering.

Accenture has completed a majority stake acquisition in Dragos as part of a $4.1 billion investment in operational technology (OT) cybersecurity. Following this, Dragos finalized its acquisitions of NetRise and runZero, expanding its platform capabilities to include firmware-level device exposure insight, software supply chain visibility, asset discovery, exposure assessment, and attack surface intelligence. These acquisitions aim to enhance defense across extended OT environments in critical infrastructure sectors. No vulnerabilities or exploits are reported in this transaction.

French cybersecurity firm CrowdSec confirmed that approximately 300 of its GitHub repositories, including about 170 private ones, were compromised in a supply chain attack linked to the May 2026 TanStack incident. Source code for CrowdSec's SaaS console, AWS Cloud routines, connectors, and automations was stolen. No customer credentials or data were leaked, and the stolen code cannot be used out of context to cause harm. CrowdSec rotated all potentially affected tokens and credentials immediately after discovery and continues to monitor for abnormal activity.

### Summary `Repo.__init__` decides which directory is the git directory by testing candidate paths in an order that considers the real `.git` **last**. Two earlier tests can be satisfied by ordinary tracked files. Git reserves only the literal name `.git`, so `HEAD`, `objects/`, `refs/`, `config`, `gitdir`, `commondir` and `hooks/` at a repository root are all legal tracked content. Consequently, after a victim opens or clones an attacker's repository, GitPython resolves `git_dir` to the **working-tree root** while real git correctly resolves `<root>/.git`. Everything GitPython then treats as "inside the git directory" is attacker-authored content — including `hooks/`, which it executes. ### CVE-2026-87817 ### Affected code (3.1.59) The discovery loop in `git/repo/base.py` tests, in order: 1. `git/repo/base.py:299` — `isfile(curpath/gitdir)` **and** `isfile(curpath/commondir)` **and** `isfile(curpath/HEAD)` 2. `git/repo/base.py:320` — `is_git_dir(curpath)` 3. `git/repo/base.py:341` — `dotgit = osp.join(curpath, ".git")` ← the real git dir, considered last `is_git_dir` (`git/repo/fun.py:60`) requires only that `objects/` and `refs/` are directories and that `HEAD` is a file; **`HEAD`'s contents are never parsed.** The hook path is resolved from `index.repo.git_dir` (`git/index/fun.py:73`), i.e. the mis-resolved directory. ### Proof of concept Requires only `pip install GitPython==3.1.59`. Full script attached as `poc1_rce.py`; it runs entirely in a temp directory and the payload only writes a marker file. Attacker repository — four ordinary tracked files at the root: | path | mode | content | |---|---|---| | `gitdir` | 100644 | `.git\n` | | `commondir` | 100644 | `.git\n` | | `HEAD` | 100644 | `ref: refs/heads/master\n` | | `hooks/pre-commit` | **100755** | `#!/bin/sh` + payload | Victim — two ordinary calls: ```python repo = git.Repo.clone_from(url, dst) # or git.Repo(dst) repo.index.commit("automated commit") # code execution happens here ``` Observed on the PyPI release 3.1.59 (Linux and Windows): ``` real git says the git dir is : /tmp/.../victim/.git GitPython says it is : /tmp/.../victim <- shadowed attacker's hook executed : True git fsck : (clean) ``` The `pre-commit` hook runs at `git/index/base.py:1201`, before `write_tree()`, so it fires even though the commit later fails. ### Impact A service that opens or clones an untrusted repository with GitPython — a CI runner building a fork pull request, a code-scanning/SBOM service, a mirror, a dependency bot, an AI code-review/agent tool — can be made to: 1. **Execute arbitrary commands** via the tracked `<root>/hooks/pre-commit` when the victim calls `index.commit()`. 2. **Read files outside the repository**: the tracked `<root>/config` becomes the repository config and is parsed with `merge_includes=True` (`git/repo/base.py:765`), so `[include] path = ~/.aws/credentials` discloses the file. (`Repo._config_reader` still defaults `merge_includes=True`, so the hardening added in 3.1.59 for `.gitmodules`/GHSA-7833 does not cover this path.) 3. **Write a config file to an attacker-chosen directory** via an absolute tracked `commondir`. Delivery is silent: `git clone` exits 0, `git fsck` (including `--strict`, and with `transfer.fsckObjects`/`fetch.fsckObjects=true`) reports nothing, and the clone passes every read-only probe (`head.commit`, `branches`, `is_dirty()`, `untracked_files`, `iter_commits`) because a tracked `commondir` of `.git` pins `common_dir` to the real `.git`. ### Threat model / preconditions - Attacker controls the content of a repository the victim opens or clones with GitPython (public repo, fork PR, mirrored dependency). - For code execution, the victim performs a commit via GitPython's native `index.commit()`. For the file-read impact, opening the repo and reading config is enough. - `GIT_WORK_TREE` is **not** a mitigation — `git_dir` is assigned and the discovery loop breaks before the environment is consulted. - Real git is unaffected; only GitPython mis-resolves the directory. ### Remediation 1. Test `curpath/.git` **before** the `gitdir`/`commondir`/`HEAD` triple and before `is_git_dir(curpath)`. 2. Resolve `hook_path` / `_commit_hook_path` / `_get_validated_reflog_path` through `repo.common_dir`. 3. Containment-check `commondir`/`gitdir` contents before joining (reuse `SymbolicReference._get_validated_path`). 4. Validate `HEAD` in `is_git_dir` (require `ref: refs/...` or a 40-hex sha). 5. Pass `merge_includes=False` in `Repo._config_reader` (`git/repo/base.py:765`). ### Note for the maintainers Commit `406b98e1` (2026-05-31, "respect core.hooksPath for commit hooks") resolved the hook path via `git rev-parse --git-path`, which is immune because git rediscovers the true `.git`. Commit `9bc287a2` (2026-07-20) reverted it to avoid an unconditional `rev-parse` dependency — reintroducing the exec step. Measured at each commit with the healthy-lo

A security researcher named Gal Weizman disclosed a browser security research achievement involving a single browser extension that successfully exploited vulnerabilities in Chrome, Comet, Edge, Opera, and Claude in Chrome. This research led to the discovery of two CVEs and earned $20,000 in bounty rewards from multiple major vendors including Anthropic, Perplexity, Google, Microsoft, and Opera. No detailed technical information or affected versions are provided.

ChainScript is a Node.js remote access trojan (RAT) identified by Blackpoint's Adversary Pursuit Group. It masquerades as legitimate software such as Spotify, Zoom Workplace, and Microsoft Teams via malicious Windows Installer packages. The malware uses a Polygon blockchain smart contract to dynamically discover its command and control (C2) infrastructure, allowing operators to rotate backend services without rebuilding agents. ChainScript offers extensive remote access features including shell access, file operations, screenshots, payload deployment, cryptocurrency wallet discovery, remote JavaScript execution, self-updating, and cleanup. Multiple builds with different names share the same core architecture.

SLDP (Simple Layer-2 Discovery Protocol) is a lightweight, stateless Layer-2 bootstrapping protocol designed to automate discovery between IPv4-only and IPv6-only devices on a common broadcast domain. It operates directly over Ethernet frames without requiring IP stack initialization and is intended as a commissioning tool rather than a runtime protocol. SLDP uses a dedicated EtherType and a two-step handshake to establish MAC-to-IP mappings, facilitating integration in mixed IPv4/IPv6 environments such as industrial IoT and legacy networks. It is not a replacement for ARP, NDP, or LLDP and runs only on demand during device commissioning. The protocol includes a security blueprint (CLL Trust Oracle) to protect against address spoofing during discovery. No known exploits or vulnerabilities have been reported, and no patch or remediation is applicable as this is a newly proposed protocol.

The Spanish Data Protection Agency (AEPD) reported the first known data breach executed by an autonomous AI agent. The AI agent chained together multiple attack phases including a successful login, vulnerability discovery, and access to personal data such as invoices. This incident marks a potential milestone in autonomous cyberattacks where AI agents independently plan and execute complex attack sequences. The investigation is ongoing, and the exact method of breach remains unclear. The AEPD highlights the need to incorporate AI adversarial risks into risk management, improve incident response speed, enhance credential protection, and adopt AI-assisted defense mechanisms with human oversight.

BreachSpain

BragJack is a security research discovery demonstrating how a single browser extension can hijack internal browser agents across five Chromium-based browsers: Chrome, Comet, Edge, Opera Neon, and Claude in Chrome. The attack leverages the declarativeNetRequest (DNR) API to weaken security headers and redirect JavaScript resources, enabling code execution within privileged browser contexts. This allows access to sensitive capabilities such as local file access, browsing history, camera and microphone, and screenshots without user interaction. The research resulted in two CVEs and $20,000 in bounty rewards from major vendors. The vulnerabilities primarily exploit weaknesses in how these browsers handle network requests and security policies within embedded web views. No patch or remediation status is provided in the source data.

This is an announcement for a virtual summit hosted by SecurityWeek focused on Attack Surface Management (ASM). The event covers strategies and tools for discovering, prioritizing, and defending expanding digital attack surfaces. Topics include continuous asset discovery, software supply chain risk, red teaming, bug bounty programs, and penetration testing. The summit aims to help security teams improve visibility and reduce risk across complex digital environments.

AI advancements are accelerating the discovery of vulnerabilities, leaving many operational technology (OT) systems unpatchable and at risk. These OT systems often run on legacy or bespoke software that cannot be easily updated or patched. Ignoring these vulnerabilities is not a viable defense. Instead, network-based protections such as micro-segmentation, next-generation firewalls (NGFW), and intrusion prevention systems (IPS) can provide compensatory controls by filtering and blocking exploit attempts. The concept of air-gapping is often ineffective in practice due to operational shortcuts. While patching remains the best defense, these layered network protections help mitigate risks where patching is impossible.

In July 2026, IIJ discovered and analyzed an unknown .NET-based malicious tool hosted on a public directory. This tool, named PIVOTPIPE, exhibits functionality similar to Cobalt Strike Beacon, communicating with C2 servers using configurations close to default profiles and supporting numerous C2 commands. However, PIVOTPIPE differs from official Cobalt Strike Beacon through unique implementations including detection evasion code, custom loaders, and obfuscated strings. The tool consists of two components: a loader and RAT module. The loader implements AMSI bypass, indirect syscalls, and sleep masking for EDR evasion. PIVOTPIPE supports TCP Beacon and SMB Beacon functionality for peer-to-peer communication through compromised hosts. Debug artifacts suggest the tool was still under development at the time of discovery, indicating potential future enhancements.

ToolHive is a utility designed to simplify the deployment and management of Model Context Protocol (MCP) servers. Prior to 0.31.0, remote.Handler.Authenticate in pkg/auth/remote/handler.go invokes discovery.DetectAuthenticationFromServer in pkg/auth/discovery/discovery.go, whose host-side HTTP clients trust remote-server-controlled authentication discovery destinations, follow redirects without host or scheme restrictions, and do not consistently block private addresses. A malicious or compromised remote MCP server can place a resource_metadata URL in WWW-Authenticate for ParseWWWAuthenticate to extract, after which FetchResourceMetadata, OIDC issuer discovery, and well-known discovery can issue GET requests to link-local, RFC1918, or other internal services outside the server's container. The user connects to a server that the user intends to use, but the server controls the internal destination; this path does not depend on the separate NAT64 guard omission because the affected clients did not invoke IsPrivateIP, and it differs from the DCR resolver path that already refused redirects. The demonstrated primitive reaches internal-only HTTP services and reachability or error oracles, and can retrieve AWS metadata credentials where IMDSv1 accepts an unauthenticated GET, while IMDSv2 and GCP metadata prerequisites are not satisfied by the demonstrated request. This vulnerability is fixed in 0.31.0.

This threat involves cookie-controlled PHP webshells used by attackers to maintain stealthy, persistent access in Linux shared hosting environments. The webshells remain dormant until triggered by specific HTTP cookie values, reducing detection by blending into normal traffic. Attackers use obfuscation and layered payload deployment to evade discovery. Persistence is often maintained via scheduled tasks (cron jobs) within the hosting account, allowing low-noise long-term access without root privileges. The attack pattern can include long periods of inactivity followed by increased malicious activity, sometimes timed to weekends or low-monitoring periods. This technique complicates incident response and detection in shared hosting scenarios.

The SMS OTP flow fails to adequately handle error messages, allowing an attacker to infer the existence of registered user accounts based on the responses received during the OTP initiation process. This weakness can be exploited by an attacker to discover valid usernames within the system. The impact is amplified for accounts that have not configured a mobile number, as the enumeration is specifically tied to this condition. The discovery of these usernames can facilitate subsequent brute force attacks, social engineering attempts, and information leakage, potentially leading to reputational damage, loss of customer trust, and regulatory non-compliance.

Microsoft has published a draft 'Humanist AI Code of Conduct' for its MAI Models, establishing strict boundaries to prevent AI from enabling cyberattacks. The code prohibits the generation of exploit code, attack tools, and operational attack guidance, enforcing absolute constraints that cannot be overridden by users or operators. It allows AI assistance for authorized defensive cybersecurity tasks such as vulnerability discovery and malware analysis. The code also mandates transparency in AI reasoning and restricts AI agents from escalating privileges or acting beyond authorized scopes. Special review processes are planned for cybersecurity and other sensitive domains. The draft is open for public consultation before finalization.

net_if_ipv6_calc_reachable_time() in subsys/net/ip/net_if.c derives a randomized ND reachable time from ipv6->base_reachable_time as min_reachable + sys_rand32_get() % (max_reachable - min_reachable), where min_reachable = base/2 and max_reachable = 3*base/2 using integer division. When base_reachable_time is 1, both min_reachable and the modulus collapse so the function returns 0, and net_if_ipv6_set_reachable_time() stores that 0 into ipv6->reachable_time. The base_reachable_time is attacker-controlled: handle_ra_input() in subsys/net/ip/ipv6_nbr.c accepts the Reachable Time field of an incoming Router Advertisement whenever it is nonzero and <= MAX_REACHABLE_TIME, so a single unauthenticated, link-local RA carrying a Reachable Time of 1 drives the computed reachable time to 0. Router Advertisements are unauthenticated by default and require only adjacency to the target link. When a neighbor is subsequently confirmed reachable, net_ipv6_nbr_set_reachable_timer() reads the value and executes NET_ASSERT(time, "Zero reachable timeout!"). On builds with CONFIG_ASSERT enabled this triggers a fatal kernel assertion — a remote denial of service; on builds without assertions the reachable timer is armed with K_MSEC(0) and fires immediately, forcing reachable neighbors into perpetual re-solicitation (STALE), degrading Neighbor Discovery. The impact is limited to availability; there is no memory-safety, confidentiality, or integrity consequence.