Search: payload.bin
656 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Malicious | – | MaliciousGCVE Database The npm package dolyame-boxy-independent-bnpl-faq version 35.8.7 contains malicious code that downloads and executes opaque native binaries from obfuscated Cloudflare Workers hosts and fallback DNS-TXT records. The payload is saved to temporary directories and executed detached from the main process, bypassing static detection methods. The package's stated purpose is unrelated to this behavior, indicating deliberate malicious intent. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-generateid version 35.8.1 contains malicious code that, upon being required, loads a platform-specific payload from suspicious Cloudflare Workers domains. It reconstructs hostnames dynamically and uses covert DNS TXT-record fallback mechanisms to retrieve base64-encoded binary payload fragments from multiple domains. The payload is written to temporary directories under disguised filenames, given executable permissions, and executed detached from the main process. The package's stated functionality does not justify fetching and executing native binaries, indicating malicious intent. Anti-analysis techniques are employed to hinder detection and analysis. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-attachfile version 35.8.1 contains malicious code that, upon requiring its main entry, downloads and executes a native binary payload from multiple hardcoded external hosts. The payload is saved to temporary directories under disguised filenames, given executable permissions, and launched without user consent. The package impersonates a fintech product but functions as an anonymous native-binary loader with obfuscated code to evade detection. No patch or remediation information is currently available. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-inputcolor version 35.8.1 contains malicious code that executes on every import. It dynamically constructs attacker-controlled hostnames to fetch a binary payload over HTTPS or via a DNS-TXT covert channel. The payload is saved to a temporary location, given execute permissions, and run detached, allowing arbitrary code execution on the host machine. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The delivery-ci-dpat npm package version 35.1.5 contains malicious code that, upon requiring the module, downloads and executes a platform-specific binary from hardcoded Cloudflare Workers hosts. It also uses a covert DNS-TXT channel as a fallback to fetch and execute a payload. The malicious behavior is disguised as analytics or telemetry and includes run-once deduplication using a filesystem stamp. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-tabsblock version 35.8.1 contains malicious code that, upon being imported, dynamically reconstructs hostnames to fetch and execute attacker-controlled native binaries. These binaries are downloaded from Cloudflare Workers subdomains or, as a fallback, retrieved via DNS TXT record queries from specific domains. The payload is saved to temporary directories with randomized filenames, made executable, and launched detached from the main process. The package uses string obfuscation techniques to evade static detection and masquerades as a legitimate SDK. This behavior results in arbitrary native code execution on the host system whenever the package is imported. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package delivery-ci-codeceptjs-fork version 35.4.5 contains malicious code that executes remote code at install/load time. It reconstructs attacker-controlled hostnames to download platform-specific binaries, which are saved to temporary directories with disguised names, given executable permissions, and executed detached from the main process. A covert DNS-TXT channel is used as a fallback to retrieve payload data. The package also includes a second dropper component disguised as an analytics SDK with similar malicious behavior. This establishes remote code execution on any system that imports this package version. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package delivery-ci-jira-rnd version 35.5.4 contains malicious code that downloads and executes a binary from obfuscated Cloudflare Workers endpoints. It uses covert DNS-TXT channels for fallback payload delivery and writes the binary to hidden paths before executing it, evading static detection. This behavior is labeled as telemetry but is actually malicious. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package ded-pwa-c-cms version 35.9.9 contains malicious code that downloads and executes an opaque binary from obfuscated, author-controlled hosts. The binary is saved to temporary directories and executed detached from the main process, masquerading as a legitimate Microsoft diagnostic tool. Execution is conditionally gated by environment variables to evade detection. No integrity checks are performed on the downloaded payload, increasing risk of arbitrary code execution. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-stateutils version 35.8.1 contains malicious code that, upon import, loads a loader script which fetches a platform-specific binary from obfuscated Cloudflare Workers endpoints and fallback DNS-TXT domains. The payload is saved to temporary directories with disguised filenames, given executable permissions, and executed detached from the main process. The package masquerades as a monitoring and observability SDK but its actual behavior involves stealthy payload delivery and execution. No official patch or remediation guidance is currently available. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package eacq-dialog version 35.8.1 contains malicious code that downloads and executes a platform-specific binary from hardcoded external hosts. The payload is saved under disguised filenames in temporary directories, given executable permissions, and launched detached from the Node.js process. The malicious code is triggered both during setup and on every require of the package, using obfuscated string assembly to evade static detection. No integrity checks are performed on the downloaded payload, and the external hosts are unrelated to the package's stated purpose. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The bigops-telephony-mock npm package version 35.7.2 contains malicious code that executes automatically when the package is required or imported. It reconstructs destination hostnames at runtime to download a platform-specific binary from attacker-controlled domains, saves it to temporary directories under disguised filenames, sets executable permissions, and runs it detached from the main process. This behavior occurs without version pinning, hash verification, or signature checks, making it a supply chain risk. The malicious payload is also embedded as a telemetry SDK loader within the package. Execution is only prevented by an opt-out environment variable and a TTL marker file, so normal usage leads to attacker-controlled code execution on the host machine. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package ded-pwa-c-page-maker-props version 35.7.7 contains malicious code that, upon import, fetches and executes an unsigned attacker-controlled binary on the user's machine. It uses obfuscated Cloudflare Workers endpoints to download a binary payload, which it writes to temporary directories and executes detached. If the HTTPS fetch fails, it falls back to a covert DNS-TXT channel to retrieve the payload. The package falsely advertises itself as a PWA props module but provides no legitimate functionality beyond this malicious behavior. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package eacq-core version 35.8.1 contains malicious code that downloads and executes platform-specific binaries from suspicious Cloudflare Workers hosts and fallback domains. This occurs immediately upon module load without any verification, enabling arbitrary code execution on any machine that installs or imports the package. The malicious payload is obfuscated to evade detection and masquerades as an analytics SDK. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The fast-hashes package version 0.1.0 on PyPI contains malicious code that executes during installation. The setup.py file overrides the install command to decode and execute a base64-encoded payload, which downloads and runs an unverified binary from a third-party GitHub repository. This behavior enables arbitrary code execution on the installer's host. The package is a typosquatting attempt mimicking a popular library and is designed to exfiltrate cryptocurrency wallet data and potentially other sensitive information. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The fastapii package on PyPI is a malicious typosquatting package impersonating the popular fastapi library. During installation, it executes obfuscated code that downloads and runs a remote binary on Linux systems. This binary is fetched from an unrelated GitHub account without verification, and the package's real behavior is to drop and execute this payload. The payload reportedly exfiltrates cryptocurrency wallet data and potentially other sensitive information. The malicious activity is triggered only on Linux, allowing it to evade detection on other platforms. The package versions 0.1.1, 0.1.2, 0.2.0, and 0.3.0 are affected. | GCVE Database | |||
| High | 7.5 | EPSS 0.7% | CVE-2026-67422facelessuser pymdown-extensions · ReDoS High7.5EPSS 0.7%CVE Database V5CVE-2026-67422 ### Summary Four inline processors in pymdown-extensions contain regular expressions with exponential backtracking. A single untrusted Markdown line under 50 bytes drives `markdown.markdown()` into unbounded CPU on the rendering thread (seconds at ~45 bytes, growing exponentially with each added character). All four fire in the extension's **default configuration** and are reachable through the documented public API. The `caret`/`tilde`/ `betterem` blow-up was introduced by the emphasis-pattern rewrite in PR #2547 (first released in **10.13**, Dec 2024) — earlier releases used a linear `(.+?)` / `([^\s]+?)` content group — and is present through **11.0** (latest); `magiclink`'s host pattern is long-standing and affects effectively all releases. Likely **CWE-1333 (Inefficient Regular Expression Complexity)**. This is a distinct issue from CVE-2025-68142 (ReDoS in `pymdownx.blocks.caption`, `RE_FIG_NUM`, fixed in 10.16.1): different extensions, different regexes, and a different root cause (delimiter-run partition ambiguity rather than a `.`/`\.` typo). ### Details Four regexes share, or closely mirror, a vulnerable shape — an inner group that can partition a run of the delimiter character into `{2,}`-sized pieces in exponentially many ways, wrapped in a lazy `+?` that must fail before the engine can give up: | Extension | Regex | Location (`11.0`) | |---|---|---| | `pymdownx.caret` (superscript `^…^`) | `SUP2` | `pymdownx/caret.py:56` | | `pymdownx.tilde` (subscript `~…~`) | `SUB2` | `pymdownx/tilde.py:55` | | `pymdownx.betterem` (underscore `_…_`) | `SMART_UNDER_EM2` (default) | `pymdownx/betterem.py:93` | | `pymdownx.magiclink` (bare-URL autolink) | `RE_LINK` | `pymdownx/magiclink.py:56` (host at `:59`) | `pymdownx/caret.py:56` (`pymdown-extensions 11.0`): ```python SUP2 = r'(?<!\^)(\^)(?![\^\s])((?:[^\^\s]|\^{2,})+?)(?<![\^\s])(\^)(?!\^)' ``` The content group `(?:[^\^\s]|\^{2,})+?` matches a run of carets only via the `\^{2,}` branch. A run of *k* carets can be split into ≥2-length pieces in exponentially many combinations; when no caret can serve as a valid closing delimiter (the trailing `(?<![\^\s])(\^)` cannot be satisfied), the engine explores every partition before failing. `SUB2` (tilde) and `SMART_UNDER_EM2` (betterem) are the same construct for `~` and `_`. In `betterem` the default `smart_enable='underscore'` routes underscores to `SmartUnderscoreProcessor` → `SMART_UNDER_EM2` (`betterem.py:93`), which is the default-reachable, API-exploitable pattern; the non-smart `UNDER_EM2` (`:69`, used only when `smart_enable` is `asterisk`/`disable`) shares the shape but did not reproduce through the public `markdown.markdown()` pipeline on the tested payload, so a fix and regression test should target `SMART_UNDER_EM2`. `pymdownx/magiclink.py:59` has the analogous ambiguity in the host portion, where overlapping character classes let a run of dots be grouped exponentially: ```python (?:ht|f)tps?://[^_\W][-\w]*(?:\.[-\w.]+)* # host: '\.' and '[-\w.]' inside (?:...)* both match '.' ``` `SUP2`/`SUB2`/`SMART_UNDER_EM2` are applied at each delimiter occurrence via the default `PatternSequenceProcessor` subclasses (`pymdownx/util.py`); `RE_LINK` is applied by `MagiclinkPattern` (registered unconditionally at priority 85). In all four cases, rendering `markdown.markdown(src, extensions=[ext])` on untrusted `src` in default configuration is sufficient to reach the regex. ### PoC Single self-contained script; runs against the pinned release in an ephemeral env. Non-destructive — the input is ordinary Markdown text; the impact is CPU/time (a per-render alarm caps each attempt so the script terminates). ```python import signal import time from importlib.metadata import version import markdown print(f"# pymdown-extensions {version('pymdown-extensions')} / markdown {version('markdown')}") CAP = 5.0 # a single render exceeding this is treated as a hang class Timeout(Exception): pass def render(ext, text): signal.signal(signal.SIGALRM, lambda *_: (_ for _ in ()).throw(Timeout())) signal.setitimer(signal.ITIMER_REAL, CAP) t = time.perf_counter() try: markdown.markdown(text, extensions=[ext]) return time.perf_counter() - t except Timeout: return None finally: signal.setitimer(signal.ITIMER_REAL, 0) # ext -> (malicious builder, benign builder [valid & closed], ramp, hang count) CASES = { "pymdownx.caret": (lambda n: "^a" + "^" * n + "b", lambda n: "^" + "a" * n + "^", [24, 30, 36], 44), "pymdownx.tilde": (lambda n: "~a" + "~" * n + "b", lambda n: "~" + "a" * n + "~", [24, 30, 36], 44), "pymdownx.betterem": (lambda n: "_a" + "_" * n + "b", lambda n: "_" + "a" * n + "_", [24, 30, 36], 44), "pymdownx.magiclink": (lambda n: "http://a" + "." * n + " ", lambda n: "http://" + "a" * n + ".com ", [28, 32, 36], 40), } repro = [] for ext, (evil, benign, ramp, hang) in CASES. | CVE Database V5 | ||
| High | 7.0 | EPSS 1.1% | High7.0EPSS 1.1%GCVE Database ## Summary There is a critical vulnerability in Traefik's default HTTP reverse proxy that leads to unauthenticated cross-user response poisoning. When a client opens an HTTP/2 or HTTP/3 `CONNECT` request, Traefik forwards it — body included — to an HTTP/1.1 upstream over a shared `net/http.Transport`. If the upstream answers the CONNECT with a keep-alive non-2xx response without draining the body, the now-desynchronized backend socket is returned to Traefik's shared connection pool and reused for other clients, letting an attacker make a different client read a response the attacker smuggled — which may be another user's authenticated or private content. The entrypoint's `sanitizePath` option (default `true`) is not a reliable defense: backends that answer `CONNECT /` with a keep-alive non-2xx remain exploitable. The experimental FastProxy implementation was not affected. The issue is fixed by deferring the forwarded CONNECT payload until the backend accepts the tunnel, by not returning CONNECT connections to the shared idle pool, and by discarding the CONNECT body in the ForwardAuth path. ## Patches - https://github.com/traefik/traefik/releases/tag/v2.11.53 - https://github.com/traefik/traefik/releases/tag/v3.6.24 - https://github.com/traefik/traefik/releases/tag/v3.7.9 ## 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 default reverse proxy forwards a plain HTTP/2 or HTTP/3 `CONNECT` request and its body to an HTTP/1.1 upstream through a shared `net/http.Transport`. When the upstream answers the CONNECT with a keep-alive non-2xx response and does not drain the body, Traefik returns the now desynchronized backend socket to its shared pool and reuses it for other clients. An unauthenticated attacker uses this to make a different client read the attacker's smuggled response. Traefik's default proxy is `net/http/httputil.ReverseProxy` over a shared `http.Transport`, so it inherits the same root cause as the Caddy `reverse_proxy` CONNECT pool poisoning. Traefik ships one partial mitigation Caddy does not. The entrypoint option `sanitizePath` (default `true`) rewrites the forwarded CONNECT's empty path to `/`, so Traefik emits `CONNECT /` instead of authority-form `CONNECT host:port`. This is not a reliable defense. It avoids the smuggle only against backends that reject `CONNECT /` by closing the connection (Apache, nginx). Backends that answer `CONNECT /` with a keep-alive non-2xx and leave the body undrained still cross. That set includes any Go `net/http` server and gunicorn/Flask. Confirmed on the official image `traefik:v3.6.23` (a currently supported release), default configuration, against stock `go-httpbin` (Go) and `kennethreitz/httpbin` (Python gunicorn/Flask), attacker and victim in separate containers, over both HTTP/2 and HTTP/3. ## Affected - `traefik:v3.6.23` (official image) and current v3, default configuration, standard proxy to an HTTP/1.1 upstream. Backend keep-alive pooling is on by default (`MaxIdleConnsPerHost` 200). - Attacker frontend is HTTP/2 or HTTP/3. An HTTP/1.1 frontend is not affected. - The upstream keeps the connection alive after a non-2xx to the forwarded CONNECT and does not drain the body. - The experimental FastProxy implementation is not affected (see Not affected). ## Details Three behaviors compose. 1. Traefik forwards a plain CONNECT as an ordinary proxied request. The default proxy is `httputil.ReverseProxy` with a shared `http.Transport` (`pkg/proxy/httputil/proxy.go`). The director assigns the outbound `URL.Host` directly and does not reject CONNECT, leaving the request body a live stream. The client places a raw HTTP/1.1 request in that body (H2/H3 DATA frames), which is written onto the backend socket after the CONNECT header block. 2. `net/http` writes the CONNECT body unframed and pools the socket. For a CONNECT the transport writes the body with no `Content-Length` and no `Transfer-Encoding`. The upstream answers a keep-alive non-2xx and parses the trailing bytes as a pipelined request. Go reads the non-2xx response and returns the socket to the shared idle pool once the request body reaches EOF (the `wroteRequest` gate), while the smuggled request's response is still pending. 3. Desynchronized reuse. The smuggled request targets a slow endpoint so its response arrives after the socket is pooled. A different client that reuses the socket reads the pending smuggled response as its own. `sanitizePath` (default `true`, `pkg/server/server_entrypoint_tcp.go`) calls `req.URL.JoinPath()`, which turns the CONNECT's empty path into `/`. Traefik emits `CONNECT /`. Whether that stops the smuggle depends only on the backend: Apache and nginx answer `400 Bad Request` with `Connection: close` (socket torn down, no cross); Go `net/http` and gunicorn/Flask | GCVE Database | ||
| Malicious | – | MaliciousGCVE Database The npm package helmet-pro@10.0.4 is a typosquatting malicious package that executes arbitrary remote code during installation. It uses an obfuscated postinstall script that fetches and executes attacker-controlled code from a remote JSON bin, enabling dynamic payload updates without republishing. The package disguises itself as a legitimate SMTP-related module to evade detection. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package statist-browser-typed-client-sme.rko.tariffs.web version 20.3.8 contains malicious code that, upon require(), downloads and executes a platform-specific binary payload from obfuscated command and control servers. The payload is saved with deceptive filenames and executed detached from the parent process. The package uses fallback covert DNS TXT channels if HTTPS fetching fails. There is no integrity verification of the downloaded binary. Systems with this package installed should be considered fully compromised. | GCVE Database |
Page 8 of 33