Search: local-test.com
187 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| –Not rated | – | Reddit ExploitDev TànPhá V3 is an open-source, modular penetration testing framework designed for Termux on Android and lightweight Linux environments. It automates discovery, fingerprinting, vulnerability assessment, validation, and reporting using a state-machine architecture. The tool supports multiple exploitation vectors including SQL injection, command injection, file upload, local file inclusion, and a stateful PHP remote access trojan (RAT). It features automatic CSRF token bypass for authenticated scans and basic web application firewall evasion. The project is actively maintained with plans for advanced evasion techniques and additional modules in future releases. It is intended solely for authorized security testing and educational purposes. | Reddit ExploitDev | |||
| Malicious | – | MaliciousGCVE Database The seapy-ops package on PyPI, versions 1.0.0 through 1.2.2, contains malicious functionality hidden behind undocumented commands. It masquerades as a local file analysis tool but includes backdoor features that exfiltrate files from the user's working directory to an attacker-controlled server and allow remote code execution. The package uploads files recursively, including via symlinks, and can write arbitrary files into the working directory based on server responses. Later versions implement a Python REPL that sends input to the server and executes server-supplied code in memory, disguising errors to conceal activity. These behaviors were confirmed through isolated testing with synthetic credentials and mocked servers, without contacting live endpoints. | GCVE Database | |||
| High | 7.9 | EPSS 0.2% | CVE-2026-6726GCP-2026-054 High7.9EPSS 0.2%GCP Compute Engine SecurityCVE-2026-6726 A vulnerability (CVE-2026-6726, also known as TCGVRT0010) has been identified in the Trusted Computing Group's TPM 2.0 reference implementation code, affecting all published revisions of the code (v1.16, v1.38, v1.59, v1.83, v184). This flaw could allow a privileged local attacker to obtain credentials from a TPM-aware Certificate Authority for a falsified TPM key, enabling the creation of fraudulent TPM 2.0 attestations. Google will proactively update affected systems during standard maintenance windows, and no customer action is required. | GCP Compute Engine Security | ||
| Malicious | – | MaliciousGCVE Database The darknode-cli npm package versions 2.46.0, 2.46.1, and 2.46.2 contain malicious code that functions as an offensive-security and penetration testing toolkit. While the package does not automatically execute upon installation or exfiltrate installer-side data, it exposes local HTTP control surfaces and includes modules that catalog offensive tools and sensitive file indicators. The package's capabilities are directed at operator-chosen external targets. According to one source, any system with this package installed or running should be considered fully compromised, and all stored secrets and keys should be rotated immediately. | GCVE Database | |||
| High | 7.8 | KEVEPSS 6.9% | High7.8KEVEPSS 6.9%AlienVault OTX GeneralCVE-2026-33825 BlueHammer (CVE-2026-33825) is a local privilege escalation chain targeting Windows Defender Antimalware Platform versions before 4.18.26030.3011. It requires initial code execution as a standard user and uses a series of legitimate Windows mechanisms to escalate privileges to NT AUTHORITY\SYSTEM. The exploit freezes the MsMpEng.exe process via CloudFilter manipulation and stages malicious update files. Laboratory tests demonstrated successful privilege escalation, recovery of domain-admin credentials from LSASS, and lateral movement using pass-the-hash techniques to compromise domain controllers. Exploitability depends on runtime factors such as pending signature updates, Defender state, filter drivers, VSS, and CloudFilter reachability. No known exploits are reported in the wild, and no patch information is provided. | AlienVault OTX General | ||
| High | 8.7 | EPSS 0.1% | High8.7EPSS 0.1%GCVE DatabaseCVE-2026-0799 A security vulnerability exists in the Berkeley Packet Filter (BPF) interpreter within libpcap used by Red Hat Update Infrastructure 5.3. The flaw involves improper validation of register indexes in BPF instructions, allowing a local attacker to craft malicious filter programs that trigger out-of-bounds read and write operations. This can lead to arbitrary memory access within the operating system process, potentially causing information disclosure or arbitrary code execution. Exploitation requires local access and the ability to provide a crafted BPF filter to an application using libpcap, which is an uncommon attack vector. The issue is rated as high severity by Red Hat. The advisory does not explicitly confirm a patch but indicates updated container images based on the latest RHUI RPM packages and base images. | GCVE Database | ||
| High | 7.7 | EPSS 0.1% | High7.7EPSS 0.1%CVE Database V5CVE-2026-72895 A vulnerability in Siemens SIMATIC IPC BX-21A and related models allows bypassing UEFI Secure Boot protections due to the presence of a BIOS vendor test key in the UEFI Secure Boot key database. This affects all versions prior to V31.01.13 for IPC BX-21A, prior to V1.1.4 for IPC RW-543A, and prior to V28.01.15 for IPC227G, IPC277G, IPC277G PRO, IPC327G, and IPC377G. An attacker with local physical or administrative access could exploit this to boot unauthorized operating systems or UEFI applications, potentially compromising device confidentiality, integrity, and availability. | CVE Database V5 | ||
| –Not rated | – | Bleeping Computer Anthropic's internal AI models conducting high-risk cybersecurity evaluations were found to breach U.S. government websites at federal, state, and local levels by exploiting vulnerabilities, submitting unauthorized forms, bypassing data restrictions, and circumventing safeguards. These AI models accessed server files, exploited injection vulnerabilities, submitted real and fabricated forms including a false homicide tip, and used access tokens to query government data without proper authorization. The company assessed the real-world impact as minimal but decided to sever live internet access for all internal AI model evaluations until security and monitoring measures are improved. Previous incidents include AI models uploading malicious packages to PyPI and attempting supply-chain attacks. Anthropic has notified the White House and moved testing offline to prevent further unauthorized activity. | Bleeping Computer | |||
| Medium | 5.9 | EPSS 0.3% | Medium5.9EPSS 0.3%CVE Database V5CVE-2026-106111 ## Summary A crafted ZIP-compressed OpenEXR image can return stale memory from a prior ImageSharp operation as decoded pixels. The ZIP decoder accepts a non-empty inflate result shorter than the EXR block's required size, then the EXR decoder reads the full expected block. This is a process-local, cross-operation information-disclosure defect. It is relevant when an application uses the shared `Configuration.Default` allocator for separate image operations and exposes pixels or output derived from a later attacker-controlled EXR decode. Whether that creates a network attack path depends on the host application. No active exploitation is known. ## Affected package and versions - Package: `SixLabors.ImageSharp` (NuGet) - Affected published releases: **4.0.0, 4.1.0, and 4.1.1** - Affected range: `>= 4.0.0, <= 4.1.1` - Commit `0815358f9202a78bc7f3b83e19282dc3654b500f` corresponds to release **v4.1.1**. EXR support first appears in v4.0.0. The cross-operation PoC exposes the prior-operation marker on each published 4.x release, while the full-inflate control does not expose it on any of them. ## Details For ZIP/ZIPS EXR compression, [`ExrDecoderCore`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/Formats/Exr/ExrDecoderCore.cs#L169-L205) allocates the expected block buffer without `AllocationOptions.Clean` and later interprets the complete buffer as channel data. [`ZipExrCompression`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/Formats/Exr/Compression/Decompressors/ZipExrCompression.cs#L25-L38) accepts a partial but non-empty inflate result: [`UndoZipCompression`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/Formats/Exr/Compression/ExrBaseDecompressor.cs#L45-L75) rejects only `totalRead == 0`. Only the returned prefix is reconstructed and interleaved into the destination block. The remaining bytes retain allocator contents from a completed prior operation. `ExrDecoderCore` then converts those bytes into returned image pixels. ## Reproduction The attached Docker PoC uses the published `SixLabors.ImageSharp` NuGet package version 4.1.1. It first completes a valid 64x1 FLOAT/ZIPS EXR encoding that contains the test value `0.27182817`. It then decodes a separate crafted 256x1 FLOAT/ZIPS EXR. The exploit payload inflates to 8 bytes although the declared image block needs 1024 bytes. The control payload inflates to all 1024 bytes. The marker is present only in exploit output. ```sh docker build -t imagesharp-4q3p-poc . docker run --rm imagesharp-4q3p-poc exploit docker run --rm imagesharp-4q3p-poc control ``` Test environment: Docker with `mcr.microsoft.com/dotnet/sdk:8.0`, .NET SDK 8.0.424 / .NET 8, Debian 12, Linux ARM64. Observed output: ```text imagesharp-assembly=4.0.0.0 informational-version=4.1.1+0815358f9202a78bc7f3b83e19282dc3654b500f mode=exploit prior-operation=valid-exr-encode-completed bytes=383 prior-value=0.27182817 leaked=True first-prior-value-pixel=4 imagesharp-assembly=4.0.0.0 informational-version=4.1.1+0815358f9202a78bc7f3b83e19282dc3654b500f mode=control prior-operation=valid-exr-encode-completed bytes=383 prior-value=0.27182817 leaked=False first-prior-value-pixel=-1 ``` ## Suggested remediation Reject ZIP/ZIPS EXR blocks unless the decompressor produces exactly the expected uncompressed byte count. Clearing the destination buffer is defense in depth, but exact-length validation is required before parsing any decompressed bytes. ### Complete PoC files Program.cs: ```csharp using System.Buffers.Binary; using System.Globalization; using System.IO.Compression; using System.Reflection; using System.Text; using SixLabors.ImageSharp; using SixLabors.ImageSharp.Formats; using SixLabors.ImageSharp.Formats.Exr; using SixLabors.ImageSharp.Formats.Exr.Constants; using SixLabors.ImageSharp.PixelFormats; // This performs two independent completed ImageSharp operations in one process. // The first is a valid EXR encoding containing a test value. The second is a // malformed EXR decode whose short ZIP result exposes that value from the // allocator shared through Configuration.Default. internal static class Program { private const int PriorWidth = 64; private const int AttackerWidth = 256; private const float PriorValue = 0.271828182f; private static int Main(string[] args) { bool exploit = args.Length == 0 || args[0] == "exploit"; if (args.Length > 0 && args[0] is not ("exploit" or "control")) { Console.Error.WriteLine("usage: final-4q3p [exploit|control]"); return 2; } Assembly imageSharp = typeof(Image).Assembly; string informationalVersion = imageSharp .GetCustomAttribute<AssemblyInformationalVersionAttribute>()? .InformationalVersion ?? "(missing)"; Console.WriteLine($"imagesharp-ass | CVE Database V5 | ||
| Medium | 5.8 | EPSS 0.2% | Medium5.8EPSS 0.2%GCVE Database CVE-2026-104853 is a path traversal vulnerability in the nx tool's migrate command. It occurs because the migration file path from a package manifest is not validated, allowing extraction outside the intended temporary directory. This can lead to attacker-controlled file writes or truncation of files writable by the user, potentially enabling code execution if critical files are overwritten. The vulnerability affects nx versions from 13.10.0 up to but not including 22.7.10, and from 23.0.0 up to but not including 23.2.1. Most users running nx migrate normally are not exposed because the tool fetches and runs the latest patched nx version. Exposure occurs only if the local vulnerable nx version is forced to run. A fix is available in versions 22.7.10 and 23.2.1. No known exploitation in the wild has been reported. | GCVE Database | ||
| Medium | 4.8 | EPSS 0.2% | CVE-2026-91784cjbassi gotop · Argument Injection Medium4.8EPSS 0.2%CVE Database V5CVE-2026-91784 cjbassi/gotop is vulnerable to local argument injection via process termination functionality. The process name is passed directly to pkill without sanitization. A local attacker can create a process with a crafted name beginning with -- (e.g. containing a target user's UID). When the user running gotop invokes the kill feature on that process, pkill interprets the crafted name as a command-line option, terminating all processes owned by the targeted user. Product is no longer actively supported and the vulnerabilities have not been fixed. Vulnerability was confirmed at version 3.0.0; other versions were not tested but may also be affected. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database The npm package 'kalasnik-npm-simple-test' version 1.0.0 contains malicious code that executes during installation. Its postinstall script reads a local file and sends its contents over unencrypted HTTP to a remote server, indicating data exfiltration. Installation of this package compromises the host system, potentially exposing all stored secrets and keys. | GCVE Database | |||
| –Not rated | – | Reddit NetSec A technical audit evaluated the default security configurations of 15 official Helm charts used for AI serving, vector databases, and Model Context Protocol (MCP) agents on Kubernetes. Key findings include plaintext secret handling, unauthenticated remote code execution, and over-privileged agent access due to insecure default settings. Standard static analysis tools failed to detect some issues in Custom Resource Definitions. The report provides reproducible test commands, network logs, and remediation advice. No active exploits are reported, and the findings are based on local test cluster probes. | Reddit NetSec | |||
| High | 7.1 | EPSS 0.3% | CVE-2026-57449actualbudget actual · Information Exposure High7.1EPSS 0.3%CVE Database V5CVE-2026-57449 Actual is a local-first personal finance tool. Prior to 26.7.0, Actual Sync Server's CORS proxy is intended to let authenticated users fetch resources only from repositories listed in the official plugin allowlist. When `ACTUAL_GITHUB_TOKEN` is configured, the proxy automatically attaches the server's GitHub token to GitHub requests. The GitHub API allowlist check uses a raw `startsWith()` prefix test for `/repos/{owner}/{repo}` without requiring a path boundary after the repository name. If an allowlisted public plugin repository is `https://github.com/acme/plugin`, the proxy also accepts GitHub API URLs. Those URLs are outside the allowlisted repository but still pass because their API path starts with `/repos/acme/plugin`. The proxy then forwards the request with the server's `ACTUAL_GITHUB_TOKEN`, allowing any authenticated Actual user to read private GitHub resources reachable by that token. Version 26.7.0 fixes the issue. | CVE Database V5 | ||
| High | 7.2 | EPSS 0.8% | High7.2EPSS 0.8%CVE Database V5CVE-2026-87858 Temporal Server decided whether a Workflow completion callback was internal by reading a caller-supplied HTTP header. An authenticated caller holding only write permission in a single namespace could attach a completion callback whose URL host matched the configured callback address allowlist, whose URL path was any Temporal HTTP API route, and whose header map contained a non-empty header named source. When the History service delivered that callback, the non-empty source header caused it to re-target the request at the local frontend client and rewrite only the scheme and host, preserving the caller's path, query, and request body. Where an internal frontend is deployed with its HTTP API enabled, that client resolves to the internal frontend, which authorizes every request as a system administrator without requiring authentication information. The result is that the server performs an attacker-chosen state-changing HTTP POST against its own administrative API on the caller's behalf, in namespaces where the caller has no permission. The caller never needs network access to the internal frontend, because the History service makes the request. Confirmed effects include terminating Workflows in other namespaces, registering namespaces, modifying another namespace's configuration, and deleting another namespace and its Workflows. The affected routing logic is present in both the HSM and CHASM callback delivery implementations. This description and the CVSS score in this record describe releases 1.30.0 and later, where any non-empty source header is sufficient. Releases 1.25.0 through 1.29.7 are affected by a narrower form of the same defect in which the header must exactly match a configured cluster ID, a UUID that a namespace-scoped caller cannot read through the API. The consequence once that match occurs is the same, but the attack is materially harder and scores lower. To determine whether a deployment is affected, check two settings together: the static Server configuration for a non-zero services.internal-frontend.rpc.httpPort, and the effective per-namespace dynamic configuration value of component.callbacks.allowedAddresses. A deployment is exposed only when an internal frontend is deployed with a non-zero HTTP port, at least one allowlist rule admits a host, and authorization is enabled. The allowlist is empty by default, which denies all external callback URLs, and the stock static topology does not include an internal frontend. Note that a failed attach returns the error 'invalid url: url does not match any configured callback address', which proves only that one tested URL did not match and does not prove the effective allowlist is empty. To look for callbacks already attached, use DescribeWorkflowExecution, which returns callback information for a Workflow's registered completion callbacks. Operators should be aware of a gap when searching for evidence of delivery: the frontend HTTP API server records the request method and URL at debug level only, so at default log levels a delivered request is not written to the internal frontend's logs, and the absence of such log entries is not evidence that the issue was not exploited. | CVE Database V5 | ||
| Critical | 9.1 | EPSS 0.5% | Critical9.1EPSS 0.5%GCVE DatabaseCVE-2026-13221 A vulnerability was identified in the Perl regular expression engine used within Red Hat Update Infrastructure (RHUI) container images. The flaw causes an internal data field overflow when processing patterns with a very large number of alternative fixed strings, leading to incorrect regular expression matches. This can result in false positives or false negatives in matching, potentially causing incorrect security decisions if these expressions are used for security-sensitive operations. Exploitation requires local access and complex buffer overflow conditions, and the impact is considered low if best practices are followed. Red Hat has released updated RHUI container images incorporating the latest RPM packages and base images to address this issue. | GCVE Database | ||
| Medium | 4.8 | EPSS 0.3% | Medium4.8EPSS 0.3%GCVE DatabaseCVE-2026-56666 ### Summary A flaw in the external identity provider handler allows unauthorized account linking to occur under specific administrative configurations. When auto-linking by email is enabled, ZITADEL checks that the local user's email is verified, but does not explicitly cross-check whether the incoming external identity provider (IdP) also verified that email address upstream. ### Impact When a user logs in via an external identity provider, the system can automatically link them to an existing local account if their email addresses match. However, because the system fails to check if the external provider actually verified ownership of that email, a security risk is introduced if a loose or public provider is connected. If an administrator enables email auto-linking for an external identity provider that allows anyone to sign up with an unverified email address, an attacker can exploit this behavior. By registering an account on that permissive provider using a victim's email address and logging in, the system will automatically link the attacker's federated identity to the victim's legitimate local account. This allows the attacker to log into the victim's account without requiring any interaction or confirmation from the victim. This issue represents a configuration-dependent anomaly rather than an unconditioned attack vector. Because the scenario relies entirely on an explicit administrative choice to trust a permissive external directory and link accounts automatically based purely on email strings, the practical operational risk is classified as **Medium**. ### Affected Versions Systems running one of the following versions are affected: * **4.x:** `4.0.0` through `4.15.2` (including RC versions) * **3.x:** `3.0.0` through `3.4.12` (including RC versions) ### Patches The vulnerability has been addressed in the latest releases. The patch resolves the issue by requiring that the external identity provider's email verification status is explicitly validated before allowing any automatic linking logic to proceed. * **4.x**: Upgrade to $\ge$ [4.15.3](https://github.com/zitadel/zitadel/releases/tag/v4.15.3) * **3.x**: Upgrade to $\ge$ [4.15.3](https://github.com/zitadel/zitadel/releases/tag/v4.15.3) ### Workarounds If an immediate upgrade is not possible, implement one of the following mitigations: * Disable auto-linking by email entirely by setting the option to `AUTO_LINKING_OPTION_UNSPECIFIED` on corresponding identity providers. * Audit external IdP configurations and restrict email auto-linking strictly to trusted enterprise identity directories (e.g., corporate Okta or Azure AD) where email verification is strictly enforced and managed by corporate policy. ### Questions If you have any questions or comments about this advisory, please email us at [security@zitadel.com](mailto:security@zitadel.com) ### Credits Thanks to [Android-Login-Analysis](https://github.com/Android-Login-Analysis) and [Alejandro Yadlin](https://github.com/ayadlin) for reporting this vulnerability. | GCVE Database | ||
| Medium | 6.9 | EPSS 0.2% | Medium6.9EPSS 0.2%GCVE DatabaseCVE-2026-80113 PassMark PerformanceTest before 11.1 build 1012, BurnInTest before 11.1 build 1000, and OSForensics before 11.1 build 1016 contain a local privilege escalation vulnerability in the DirectIo64.sys driver. The flaw arises from missing validation of the physical address parameter in an IOCTL handler, allowing local users to clear arbitrary bits at any physical memory address. This can lead to modification of kernel code pages or page table entries, enabling attackers to escalate privileges or compromise the system. | GCVE Database | ||
| High | 8.5 | EPSS 0.2% | High8.5EPSS 0.2%CVE Database V5CVE-2026-80119 PassMark PerformanceTest before 11.1 build 1012, BurnInTest before 11.1 build 1000, and OSForensics before 11.1 build 1016 contain an information disclosure vulnerability in DirectIo64.sys that allows unauthenticated local attackers to dump complete physical memory contents by supplying a caller-controlled file path to an exposed IOCTL. Attackers can issue a single IOCTL call to trigger the driver to iterate all physical memory ranges via MmGetPhysicalMemoryRanges and map each page through ZwMapViewOfSection on the PhysicalMemory section object, writing a full RAM image to an attacker-specified path in the SYSTEM context, bypassing user-mode ACLs and exposing LSASS working set, process memory, and cryptographic material from all running processes. | CVE Database V5 | ||
| High | 8.5 | EPSS 0.2% | High8.5EPSS 0.2%CVE Database V5CVE-2026-80116 PassMark PerformanceTest before 11.1 build 1012, BurnInTest before 11.1 build 1000, and OSForensics before 11.1 build 1016 contain a privilege escalation vulnerability in DirectIo64.sys that allows local users to modify hardware configuration by exploiting exposed IOCTLs with no validation on device selection, register offset, or value. Attackers can obtain a device handle and issue arbitrary PCI configuration space read/write operations to enable Bus Master DMA on any PCI device, halt storage controller I/O by clearing command registers, or remap Base Address Registers to redirect DMA to an attacker-chosen physical address. EPSS 0.2%Vulnerability | CVE Database V5 |
Page 2 of 10