Search: File.txt.exe
149 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Low | 3.3 | CVE-2026-127095Red Hat Ansible Automation Platform 2 · ReDoS Low3.3CVE Database V5CVE-2026-127095 A flaw was found in ansible-builder. The regular expression used to strip comments from a collection's requirements.txt during introspection is susceptible to super-quadratic backtracking. A requirements file containing a line with a long run of internal whitespace and no comment character causes the comment-stripping routine to consume CPU time proportional to the square of the line length. An attacker who can get a victim to build an execution environment that includes an attacker-supplied collection can cause the ansible-builder build or introspect process to hang, resulting in a denial of service. This issue has no confidentiality or integrity impact. | CVE Database V5 | |||
| Critical | 9.4 | EPSS 0.9% | Critical9.4EPSS 0.9%CVE Database V5CVE-2026-119623 The installer (first installation wizard) could be re-enabled on an already configured instance by placing a file whose name starts with FIRST_INSTALL in the public web root or the project root. The installer then became accessible without authentication, allowing for example to change the database connection and to create a new administrator and system maintainer account, which leads to remote code execution. As demonstrated in TYPO3-CORE-SA-2026-026, such a file could be created by an authenticated, low-privileged backend user without any further permissions. Other ways of creating files in the web root, as well as leftover or restored marker files, could be abused in the same way. With the fixed versions, the installer can no longer be re-enabled on an already configured instance by a marker file. A new internal setting $GLOBALS['TYPO3_CONF_VARS']['SYS']['isInstalling'] is stored in the system configuration and is only enabled while a new installation is running. Additionally, only the exact file names FIRST_INSTALL and FIRST_INSTALL.txt are accepted as marker files. | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.3% | CVE-2026-63166Omnispace Agora Project · Cross-site Scripting Medium5.3EPSS 0.3%CVE Database V5CVE-2026-63166 Omnispace Agora Project through 26.10.0 contains a stored cross-site scripting vulnerability that allows attackers to inject malicious HTML markup by controlling imported directory data or an uploaded CSV file, as values are rendered into table cell text and value attributes after only Txt::utf8Encode() with no HTML escaping in VuePersonsImportExport.php. Attackers can craft a CSV cell containing an attribute-breakout payload that is rendered verbatim and executed in the browser of the administrator performing the import, leading to arbitrary script execution in the administrative context. EPSS 0.3%Vulnerability | CVE Database V5 | ||
| High | 7.8 | EPSS 0.2% | High7.8EPSS 0.2%CVE Database V5CVE-2026-16305 CVE-2026-16305 is a local privilege escalation vulnerability in INFINITT Healthcare System Manager versions 3.0.11.3 through 3.0.11.5. It arises from incorrect permission assignment on a critical resource, specifically a world-writable command manifest file (execlist.txt) processed by SmartUpdate.exe and SmartExecute.exe during application updates. This flaw allows a local attacker with low privileges to execute arbitrary commands with administrator rights. | CVE Database V5 | ||
| Medium | 5.6 | EPSS 0.4% | CVE-2026-113730orphan-oss ognl · Protection Mechanism Failure Medium5.6EPSS 0.4%CVE Database V5CVE-2026-113730 ### Summary OGNL's optional *stricter invocation* mode maintains a block list that prevents expressions from directly calling methods on dangerous classes such as `Runtime`, `ProcessBuilder`, and `ClassLoader`. The block list filters on the **declaring class of the method OGNL invokes**. Because `java.lang.reflect.Method` (and `Constructor`/`Field`) are not on the list, an expression can use reflection as a proxy — `someMethod.invoke(target, args)` — to reach a blocked method. The real call (e.g. `ProcessBuilder.start()`) then executes inside the JDK reflection machinery and never passes back through OGNL's `invokeMethod`, so the block list never sees it. ### Proof of concept Under the default OGNL context (public-only access, stricter invocation enabled), the following expression creates a file even though a direct `new ProcessBuilder(...).start()` is blocked: ``` (#pb=new java.lang.ProcessBuilder({"/usr/bin/touch","rce-proof.txt"}), #methods=@java.lang.ProcessBuilder@class.getMethods(), #names=#methods.{ #this.getName() }, #startIdx=#names.indexOf("start"), #methods[#startIdx].invoke(#pb, null)) ``` ### Impact and scope — please read carefully **This is hardening of a defense-in-depth secondary layer, not a break of OGNL's primary security boundary.** In OGNL the stricter-invocation block list is a *secondary* mitigation. The **primary** access-control gate is the `MemberAccess` implementation supplied by the integrating framework or application, which OGNL consults on every constructor and method call. Frameworks that evaluate untrusted expressions are expected to install a restrictive `MemberAccess` — for example, Apache Struts' `SecurityMemberAccess`, which excludes dangerous classes and the `java.lang.reflect` package. Against such a `MemberAccess` this PoC is blocked at the very first step (the `new ProcessBuilder(...)` constructor), before reflection is ever reachable. The default context that ships with OGNL intentionally allows all public members and is **not** designed to sandbox untrusted input. An application that evaluates attacker-controlled expressions with that permissive default already has many paths to code execution, and this technique is not required to achieve it. **You are affected only if all of the following hold:** (1) your application evaluates untrusted/attacker-controlled OGNL expressions, (2) it uses OGNL's default permissive `MemberAccess` (or an equivalently permissive one that allows `java.lang.reflect`), and (3) it relies on the stricter-invocation block list as its sandbox. **Properly configured consumers — including Apache Struts with its `SecurityMemberAccess` — are not affected.** The actual protection for untrusted-expression scenarios remains a correctly configured `MemberAccess`; the block list should not be treated as a sandbox. ### Fix `java.lang.reflect.Method`, `java.lang.reflect.Constructor`, and `java.lang.reflect.Field` are added to the stricter-invocation block list, so reflection objects can no longer be used as invocation proxies in stricter mode. The `java.lang.invoke.MethodHandle` path was verified not to be exploitable (its signature-polymorphic `invoke`/`invokeExact` fail through OGNL's reflection-based invocation), so no additional classes are required. ### Credit Reported responsibly through Tidelift by 毛锐 (youyi.mr@alibaba-inc.com). | CVE Database V5 | ||
| High | 7.2 | EPSS 0.3% | High7.2EPSS 0.3%CVE Database V5CVE-2026-103999 The Ultra Addons for Contact Form 7 plugin for WordPress is vulnerable to Stored Cross-Site Scripting via File Upload in all versions up to, and including, 3.5.54 due to insufficient input sanitization and output escaping. This makes it possible for unauthenticated attackers to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. The extension blocklist gatekeeper is bypassed by uploading text-type files (.txt, .csv, .vtt, .srt, .asc) whose contents begin with an HTML payload such as '<BODY onload=…>', as the check classifies these files as text/plain without inspecting their byte content. | CVE Database V5 | ||
| High | 7.5 | EPSS 0.4% | CVE-2026-105744docling · Path Traversal High7.5EPSS 0.4%CVE Database V5CVE-2026-105744 ### Summary When the LaTeX backend is configured to render TikZ pictures with the Tectonic engine (`LatexBackendOptions(tikz_engine="tectonic")`), the TikZ body and the document preamble from the input file are compiled by Tectonic without any restriction on TeX's file primitives. A crafted `.tex` file can read files the process can read and write files at paths the process can write. If the caller also sets `tikz_engine_allow_shell_escape=True`, the document can run shell commands through `\write18`. ### Details `docling/backend/latex/engines/tectonic.py` writes the picture source into a temporary document and runs the `tectonic` binary on it. `_resolve_local_dependency` only decides which files are staged into the temporary directory. It does not limit what TeX opens at compile time, so: - `\input{/abs/path}`, `\verbatiminput{...}` and `\openin` read arbitrary files, and their content can be typeset into the rendered picture that ends up in the conversion output. For an in-memory `DocumentStream`, staging is skipped entirely. - `\immediate\openout` / `\write` create or overwrite files outside the temporary directory. Neither needs shell escape. Tectonic's `--untrusted` flag does not block them either. Separately, the `TectonicEngine` constructor defaults to `allow_shell_escape=True`. The LaTeX backend always passes `tikz_engine_allow_shell_escape` explicitly (default `False`), so this default only affects code that instantiates `TectonicEngine` directly. ### Affected configurations - Affected: callers that set `tikz_engine="tectonic"`, have a `tectonic` binary available (on `PATH` or in the docling cache), and convert untrusted LaTeX. - Not affected: the default configuration (`tikz_engine=None`). docling does not install `tectonic` automatically, and the CLI exposes no option to enable it. ### Impact Disclosure of local files readable by the process, and creation or overwrite of files writable by the process. Writing to startup or configuration files can lead to code execution. With shell escape enabled, commands run directly. ### Proof of concept ```latex \documentclass{article} \usepackage{tikz} \begin{document} \begin{tikzpicture} \immediate\openout15=/tmp/docling-tectonic-poc.txt \immediate\write15{written by the input document} \immediate\closeout15 \node {x}; \end{tikzpicture} \end{document} ``` Converting this file with `LatexBackendOptions(tikz_engine="tectonic")` creates `/tmp/docling-tectonic-poc.txt`. ### Patches Mitigated in docling 2.132.0 by [#4419](https://github.com/docling-project/docling/pull/4419): - `TectonicEngine` now defaults to `allow_shell_escape=False`, and without shell escape Tectonic runs with `--untrusted` and `--only-cached`. - Before compiling, docling checks the generated document and every staged file. It skips rendering, and keeps the diagram as TikZ code, when the source uses the `\openin`, `\openout`, `\XeTeXpicfile` or `\XeTeXpdffile` primitives, or names an absolute, home, drive-letter or parent-directory path in `\input`, `\include`, `\includegraphics`, `\InputIfFileExists` or `\graphicspath`. This check is best-effort. It reads the source text, and TeX can open files in ways a text check cannot see, for example through package commands or names built by macros. As documented in the [pipeline options reference](https://github.com/docling-project/docling/blob/main/docs/reference/pipeline_options.md), untrusted LaTeX rendered with `tikz_engine="tectonic"` should still be processed in an isolated environment. ### Workarounds Upgrade to 2.132.0. For older versions: - Do not enable `tikz_engine="tectonic"` for untrusted input, or run the conversion in an OS-level sandbox (container, no host mounts, read-only filesystem, no network). - Never set `tikz_engine_allow_shell_escape=True` for untrusted input. | CVE Database V5 | ||
| Medium | 5.1 | EPSS 0.2% | CVE-2026-105178SourceCodester Drug Recommendation System · SQL Injection Medium5.1EPSS 0.2%CVE Database V5CVE-2026-105178 CVE-2026-105178 is a medium severity SQL injection vulnerability in SourceCodester Drug Recommendation System version 1.0. The flaw exists in the mysqli_real_escape_string function within the /Admin/add_symptom.php file, specifically in the Symptom Creation component. An attacker can remotely manipulate the txtname argument to execute SQL injection attacks. Public exploit code is available, increasing the risk of exploitation. EPSS 0.2%Vulnerability | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (ddd83408820ca65c51cea223a061260109332ba408ca3a43ba00ef827f1ad74f) preinstall.js and postinstall.js execute automatically on npm install. preinstall.js reads.env files from the current and parent directories, walks the working directory and home directory for files matching *.key, *.pem, id_rsa, id_ed25519, wallet.json, keystore.json, and mnemonic.txt, collects process.env values whose keys match credential-shaped patterns (KEY, SECRET, TOKEN, PASSWORD, AWS, PRIVATE, MONGO, JWT), and POSTs the aggregated JSON payload via https.request to https://attacker.com/collect. postinstall.js additionally captures hostname, user, uid/gid, cloud/container context (Docker, Kubernetes, AWS, GCP, Azure), and reads file contents from /root, /home, and /opt matching key/pem/mnemonic/wallet/keystore/secret, then POSTs to https://attacker.com/exfiltrate. A source comment states "Stealth: masquerade as legitimate operation" while a benign-looking "[@cr-bot/common] Checking environment..." message is printed and network errors are silently swallowed. | GCVE Database | |||
| Medium | – | EPSS 0.2% | CVE-2026-74486Linux kernel · binfmt_misc: use exe_file_deny_write_access() for the interpreter clone MediumEPSS 0.2%GCVE DatabaseCVE-2026-74486 In the Linux kernel, the following vulnerability has been resolved: binfmt_misc: use exe_file_deny_write_access() for the interpreter clone For MISC_FMT_OPEN_FILE entries load_misc_binary() clones the registered interpreter file and denies write access to the clone via plain deny_write_access(). The clone is installed as bprm->interpreter and later released by the exec machinery through exe_file_allow_write_access() which skips the i_writecount increment for files with FMODE_FSNOTIFY_HSM set. The deny and allow side can therefore come to different conclusions when pre-content watches are in play: if a pre-content watch is added to the interpreter after registration every subsequent exec through that entry takes a write denial on the clone that is never paired with a write allowance, driving the interpreter inode's i_writecount further down with each exec and leaving the interpreter unwritable even after the entry and all its users are gone. Take the write denial via exe_file_deny_write_access() so both sides of the pairing base their decision on the same file mode, and propagate failure instead of silently ignoring it: an interpreter that is concurrently open for writing now fails the exec with ETXTBSY, exactly like an interpreter freshly opened via open_exec() would. | GCVE Database | ||
| Medium | 4.8 | EPSS 0.2% | Medium4.8EPSS 0.2%GCVE DatabaseCVE-2026-74487 In the Linux kernel, the following vulnerability has been resolved: binfmt_misc: restore write access when removing an entry Registering an entry with the MISC_FMT_OPEN_FILE flag opens the interpreter via open_exec() which denies write access to it for as long as the entry exists. Removing the entry closes the interpreter file via filp_close() but never restores write access, leaving the inode's i_writecount permanently negative. Opening the interpreter for writing keeps failing with ETXTBSY long after the entry is gone until the inode is evicted from the inode cache. Commit 90f601b497d7 ("binfmt_misc: restore write access before closing files opened by open_exec()") fixed the same imbalance in the error path of bm_register_write() but the actual removal path has been leaking the write denial since the introduction of the flag. Restore write access in put_binfmt_handler() before closing the interpreter file. | GCVE Database | ||
| High | 7.5 | EPSS 0.9% | High7.5EPSS 0.9%CVE Database V5CVE-2026-13457 The InstaWP Connect – 1-click WP Staging & Migration plugin for WordPress is vulnerable to Remote Code Execution in all versions up to, and including, 0.1.3.6 via the (top-level script) function. This is due to the plugin stores its encrypted options file as options-{migrate_key}.txt in wp-content/instawpbackups/ without deploying an index.php or .htaccess to prevent directory listing, exposing the 40-character migrate_key on Apache servers with directory indexing enabled, which allows an attacker to derive the AES-256-CBC passphrase via SHA256(migrate_key), decrypt the options file to recover the api_signature. This makes it possible for unauthenticated attackers to get the database access details and api_signature. Exploitation requires the target WordPress site to be hosted on Apache with directory listing enabled (Options +Indexes) for the wp-content/instawpbackups/ directory, and time limited because it can only be exploited during the migration period. | CVE Database V5 | ||
| Low | 2.3 | EPSS 0.2% | CVE-2026-61477Red Hat Enterprise Linux 10 · CRLF Injection Low2.3EPSS 0.2%CVE Database V5CVE-2026-61477 An injection vulnerability was found in libvirt's virtual network driver. The network XML parser does not strip newline characters from DNS TXT record value attributes and SRV record domain/target attributes. These values are written verbatim into the dnsmasq configuration file generated by the network driver, allowing a user with permission to define virtual networks to inject arbitrary dnsmasq configuration directives such as dhcp-script, leading to arbitrary command execution as root. EPSS 0.2%Vulnerability | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-inputdate version 35.8.1 contains malicious code that, upon being required or imported, downloads an opaque binary from obfuscated Cloudflare Workers hosts and fallback DNS TXT record channels. The binary is saved to a hidden temporary file, made executable, and executed detached from the main process. This behavior is inconsistent with the package's stated purpose as an API client wrapper and demonstrates deliberate evasion techniques. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-sortablelist version 35.8.1 contains malicious code that, upon being imported, fetches and executes a platform-specific attacker-controlled binary. This binary is retrieved from obfuscated Cloudflare Workers hosts or reconstructed from DNS TXT records, then written to a temporary file disguised as system diagnostics output and executed detached from the main process. The package attempts to evade detection by obfuscating imports and gating execution behind environment variables related to telemetry opt-out, but the actual behavior is unauthorized remote code execution at import time. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (534ea1156519b64249657c1495faacdb3cc5d8e250a00e0dc2f8fd4e991af61c) The package's bin entries (`wormgpt-cli`, `wormgpt`, `deepholegpt`, `wgpt`) map to `bin/victim.js`, which silently spawns a detached implant on any invocation (including `--help`/`--version`). The implant connects to a hardcoded C2 at http://13.60.13.215:7771 over an AES-256-GCM/HMAC-signed protocol with pool failover and a DNS TXT dead-drop channel (`protocol.js` `pollDnsDeaddrop`) that rotates the C2 URL and shared secret at runtime. On beacon, `implant.js` `gatherInfo()` collects hostname, user, OS, architecture, PID, cwd, home, LAN IP, admin flag, and a persistent victim_id, and accepts opcodes for shell/PowerShell execution, interactive PTY reverse shell, file up/download, keylogging (`GetAsyncKeyState` PowerShell loop), clipboard capture, screenshots, LAN lateral-movement scanning, privilege-escalation checks, and anti-forensics wipe. `stealers/browser.js` reads Chrome/Edge/Brave/Opera/Vivaldi Login Data SQLite databases, decrypts DPAPI-protected passwords via PowerShell with an AMSI bypass stub (`AMSI_BYPASS_B64` base64 blob run through `powershell -EncodedCommand`), parses Firefox `logins.json`, and regex-scans Discord/Chrome LevelDB for auth tokens (`/[\w-]{24}\.[\w-]{6}\.[\w-]{27}|mfa\.[\w-]{84}/g`), exfiltrating results via C2 opcode OP_BROWSER_DATA. `persist.js` installs persistence across six autostart layers per OS: Windows HKCU/HKLM Run keys, Startup.lnk, WMI __EventFilter/CommandLineEventConsumer permanent subscription, scheduled tasks, and hidden `Windows Helper` directories via `attrib +H +S`; Linux XDG autostart, systemd --user units, `@reboot` crontab, shell RC injection (`.bashrc`/`.zshrc`/`.profile`/`.xinitrc`), and `/etc/rc.local`; macOS LaunchAgent plist with KeepAlive and Login Items via osascript. `loader.js` runs a watchdog sibling process (poll every 20s, `MAX_REVIVES = 50`) plus `uncaughtException` respawn to keep the implant alive. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package bigops-opening-file-handler version 35.9.2 contains malicious code that, when required, downloads and executes a native binary from attacker-controlled infrastructure. This binary is fetched from obfuscated Cloudflare Workers subdomains or a DNS TXT fallback, saved under disguised filenames in temporary directories, given execute permissions, and run automatically. The package falsely advertises itself as a file-handler abstraction but executes unrelated native code without user consent. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package bigops-procedure-file-handlers version 35.7.6 contains malicious code that downloads and executes a platform-specific executable from obfuscated Cloudflare Workers endpoints. It writes the executable to temporary directories with disguised filenames and runs it detached from the main process. If the HTTPS delivery fails, it uses a covert DNS TXT record channel to retrieve and execute code. The package disguises its activity as OS telemetry, indicating intentional evasion of detection. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The bigops-products-deposits npm package version 35.9.1 contains malicious code that executes automatically upon requiring the package. It downloads a binary payload from obfuscated endpoints using HTTPS and a DNS TXT fallback channel, writes it to temporary system directories under disguised filenames, sets executable permissions, and executes it detached from the parent process. This behavior results in remote code execution on the host where the package is installed. The package also uses a state file to masquerade as telemetry data. | GCVE Database |
Page 1 of 8 · 1 duplicate CVE record merged