Search: main.download
191 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (2790159028b31b656c9e704c3a0e4b1a5d114042e0d92c601d133057f760b537) streak-map-kit is advertised as a dependency-free calendar-day/streak math library but ships a Linux ELF at dist/internal/calc-mapping.bin framed as a 'native math accelerator'. The main entry's top-level async IIFE chmods the ELF to 0755 and spawns it as a detached child process whenever the module is imported, so any consumer that requires the package on Linux drops the binary as a running process. The ELF (internally named REDSHELL) beacons to a hardcoded C2 at http://217.60.77.63 and implements a full remote-shell command surface: /sysinfo, /ps, /env, /ls, /cat, /download, /upload, /ssh_keys, /creds, /dbfind, /clipboard, /kill, /spawn, /adduser, /enableuser, /sessions, with unmatched input executed via /bin/sh or /bin/bash. It exfiltrates arbitrary filesystem paths and harvested SSH keys and stored credentials via chunked POSTs to http://217.60.77.63/api/extract-receive (BIGEXTRACT_START, Loot_%s_%s_%s tagging). Second-stage payloads are fetched from http://217.60.77.63/Others/ and http://217.60.77.63/SC/ over plaintext HTTP with no verification, staged in /tmp, and executed; a memfd_create-based fileless-exec path via a python3 syscall(319) trampoline and /dlopen and /stage commands provide arbitrary further code loading. Persistence is installed by writing ~/.config/systemd/user/svc-update.service (Description='System Update Service', ExecStart=/proc/self/exe, Restart=always) and enabling it via systemctl --user, with cron, bashrc, and xdg autostart alternatives. The beacon also offers a SOCKS5 proxy, arbitrary TCP port-forwarding, and an RC2TUN tunneling protocol that spawns /bin/bash, turning the host into a pivot into reachable internal networks. Cover-story framing (comments describing a 'high-performance streak computation engine', a hardcoded sha256 'integrity verification — critical security gate', a 'Native accelerator loaded and verified' log line, and a README claim that the module performs no side effects on import) is inconsistent with the shipped ELF and the import-time spawn. ## Source: ghsa-malware (94d7354ef39adcf387d7d0a7ff293bf9bea70e2c08fc9e455ad45bfed167b57b) 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 dolyame-boxy-atom-bnpl-navigation-arrow version 35.6.5 contains malicious code that downloads and executes a platform-specific executable from attacker-controlled Cloudflare Workers hosts. If the primary download fails, it uses a DNS-TXT record covert channel to retrieve and execute the payload. The malicious executable is saved to temporary directories with names mimicking legitimate files and executed detached from the main process. The package appears to be a typosquatting or dependency confusion lure. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-clickoutsidehoc version 35.8.1 is a malicious package masquerading as a legitimate UI utility. Upon requiring the package, it loads obfuscated code that assembles hostnames to download a platform-specific executable from Cloudflare Workers domains and fallback DNS TXT covert channels. The executable is written to temporary directories under disguised names, given executable permissions, and spawned detached to run attacker-controlled native code on the host system. This package contains no legitimate UI functionality and acts as a dropper for malicious native code. | 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 devplatform-react-mcp version 35.5.6 is a malicious dropper disguised as a React MCP SDK. When loaded, it dynamically assembles hostnames to download and execute attacker-controlled binaries on the host system. It uses runtime string concatenation to evade static detection and spawns these binaries detached from the main process. The package has no legitimate native build purpose and its only observable behavior is fetching and running opaque payloads. | 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 --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (18948f1c8e71b24d05e1ef6f749995bdc9098d610f791b86dc33f7d41dd8b1d3) The package advertises itself as a streak/calendar math library, but its main entry `dist/index.mjs` contains a top-level IIFE that, on any `import`/`require`, chmods `dist/internal/map-calc.bin` to 0755 and detached-spawns it after a sha256 integrity gate. The bundled Linux x86_64 ELF is a full remote-control implant: strings show a RedShell / RC2TUN beacon to a hardcoded C2 at 217.60.77.63, command handlers for shell execution, ELF/shellcode download-and-run (including memfd_create fd exec) via HTTP paths `/Others/<file>` and `/SC/<file>`, SOCKS5 proxy and port forwarding, chunked file exfiltration via `POST /api/extract-receive HTTP/1.1` packaging loot as `Loot_<host>_<user>_<ts>`, targeted collection of SSH keys and credentials (`/ssh_keys`, `/creds`, `/dbfind`, `/download`, `/dataextract`), and reboot persistence by writing `~/.config/systemd/user/svc-update.service` (Description=System Update Service, Restart=always) and enabling it via `systemctl --user`. The JS wrapper's `Loads the native math accelerator` / `integrity verification — critical security gate` comments are cover-story framing; the hash pin exists to guarantee the exact malicious bytes execute. ## Source: ghsa-malware (062e4983092eb99ef7f5cbd663dd551a226418b0d723139e3a3f97ae70b208a2) 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 | |||
| –Not rated | – | Tenable Research Agentic AI armed attackers first, but it also put real building power in defenders’ hands. Here’s what security practitioners built in two days at Black Hat USA 2026, and how the CyberAgents Exchange keeps that work compounding long after the event. Key takeaways Building defensive cybersecurity tooling no longer requires a developer. Agentic tooling drove the cost of finding and exploiting a vulnerability down to 1990s levels; it also removed the engineering barrier that kept defenders from building the automation they’ve always wanted. The unglamorous work won the room: triage, reconciliation, toil. Given two days and a requirement to publish, practitioners at SWARM developed agents for prioritization, cross-tool reconciliation, and the unglamorous toil they recognize from their own environments. All SWARM builds live on the CyberAgents Exchange , source repos attached. Every component built at SWARM is published open source with its source repository attached, so the next team facing the same problem starts from working code instead of a blank editor. Another security team already built the AI agent you need You may not realize it, but somewhere out in the ether, there’s a security team facing the same challenge as you. The only difference is they just solved the problem with agentic AI. The problem is, you have no way to find out the solution even exists. It could be an asset inventory that three systems describe in three different ways; a findings queue nobody has the hours to work; or a “critical” that a platform upgrade quietly neutralized six months ago, still sitting there waiting for someone to prove it. Somebody has already built the thing you keep meaning to build. Now it’s time we help you find it. At Black Hat USA 2026, nearly 100 registrants had the opportunity to come together for 48 hours and solve both halves of that problem: identifying a key operational pain point and building the fix. Problems like those got solved at SWARM, and the fixes are sitting on the CyberAgents Exchange right now, open source, with their source repositories attached. One team built the agent that works out which handful of fixes retires the most risk across thousands of findings. Another correlated two scanners to tell whether a flaw in the code is even reachable in the running application. A third made the case that a finding had already been mitigated, with evidence an auditor would accept. You can download and deploy any of them today. Agentic AI doesn’t just arm attackers Black Hat’s keynote stage spent this year focused on one theme: the plummeting cost of cyber offense in the agentic AI era. The price for an attacker to find and exploit a vulnerability is at lows the industry hasn’t seen since the 1990s, when a working exploit meant weeks of expert reverse engineering. Now all it takes is an afternoon and a subscription. The artisanal exploit isn’t rare anymore. True. But neither is the defender who can build. The same agentic tooling that’s arming attackers puts real building power in everyone’s hands, and that half of the story got almost no airtime. Security automation used to require the work and ongoing maintenance of skilled engineers. Now practitioners who understand the problem can build the fix. Inside the conference room at the Mandalay Bay where Tenable hosted our inaugural SWARM event, the proof of that was on every table. The winning ranking engine ships as a skill that runs on the Python standard library alone — no packages, no install step, no build pipeline. Point it at the bundled demo estate and it answers “what should we fix first?” in seconds. That’s a deliverable a practitioner can produce and a colleague can run, and two days was enough. The attacker-defender asymmetry doesn’t stem from a lack of talent or willingness. Offensive cyber capabilities compound because the tooling circulates: it’s built once, forked, passed on, or sold to the next threat actor to leverage in their attack. Meanwhile, defenders… | Tenable Research | |||
| –Not rated | – | Kaspersky Security Blog Have you ever tried to open an “encrypted” email or an urgent document, only to realize with horror that your usual DOCX attachment is actually a file with the extension .docx.exe? Or maybe you received an email supposedly with an invoice, contract, or internal memo attached — only for the file to prove something entirely different from what it claimed to be? If so, you were likely targeted in a malware infection attempt. Cybercriminals routinely disguise malicious files as harmless documents and archives, banking on recipients blindly clicking without checking the extension. Kaspersky experts analyzed the file formats most frequently deployed in malicious email blasts to reveal what really lurks behind these extensions — and how attackers weaponize them in their campaigns. Important note: the extensions we’ll be discussing here are routinely used for completely legitimate files. For example, Windows executables normally end in .exe. However, we’re focusing specifically on scenarios where attackers disguise or spoof a file’s extension to pass it off as a totally different type of file. What extensions are most commonly found in malware? Our experts analyzed malicious email blasts from the beginning of 2026 to pinpoint the 15 most common dangerous file extensions. .exe .js .html .dll .bat .vbs .xls .pdf .jse .au3 .docx .htm .wsf .scr .lnk The top 15 file extensions used in malicious email blasts Let’s take a look at what files with these extensions actually do under the hood. Executable files An executable file is a compiled computer program that’s ready to run. Once launched, a malicious executable can download additional payloads, alter system settings, steal user data, connect your device to external attacker-controlled servers, and much more. These are the most common executable extensions found in malicious email campaigns: .exe .dll .com .scr .exe The classic Windows executable extension. It powers every program you use daily, from web browsers and games to office suites and software installers. By the way, attackers often wrap EXE malware in double extensions: invoice.docx.exe, report.pdf.exe, or even photo.jpg.exe. They take advantage of a default Windows setting: hiding extensions for known file types. Because this setting is turned on by default, users only see the first part of the file name — invoice.docx, report.pdf, or photo.jpg — and assume it’s just a normal document or image. But the second you open this trap file, the malware fires up. .dll Another common extension abused in malicious campaigns is .dll (dynamic-link library). These libraries hold functions that Windows programs frequently require while running, such as printing a document. This modular architecture prevents redundant code by letting multiple applications call on the exact same library for specific tasks. However, if an attacker replaces a legitimate library with an infected one, running any normal program that calls on it can trigger malicious code. .com While files with the .com extension have absolutely nothing to do with the web domain of the same name, cybercriminals likely count on victims mistaking these files for links in an unusual format. In reality, it’s a legacy Windows executable format. While modern versions of Windows no longer rely on this file type, the operating system can still run and execute it, which makes opening one a very bad idea. .scr SCR files are screensavers — those idle Windows screen animations featuring abstract patterns, the iconic bouncing logo, or whatever else. Despite their harmless reputation, screensavers are essentially executables just like EXE files: once opened, they can install extra components or alter system settings all the same. In malicious campaigns, these files routinely masquerade as images, screenshots, or documents. Scripts Scripts are text files containing a sequence of commands that a computer runs automatically in order. They can download files, install and launch programs, modify securi… | Kaspersky Security Blog | |||
| Low | 3.1 | EPSS 0.3% | CVE-2026-55825Contao · Possible path traversal in job download URIs Low3.1EPSS 0.3%GCVE DatabaseCVE-2026-55825 Contao versions 5.7.0 through 5.7.6 contain a path traversal vulnerability in the job attachment download endpoint. An authenticated backend user with access to one job can manipulate the attachment identifier to read files from other job directories within the job attachments storage. This occurs because the system canonicalizes the combined path but does not enforce that the resolved path remains within the authorized job directory. The vulnerability allows reading of attachments such as CSV logs from other jobs if the attacker knows the target job UUID and attachment filename. | GCVE Database | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (59c390b9379b870b37038a8ad8f52b179d2fce3aa38fc15e5d1c9dc3f0ece135) The package advertises itself as a dependency-free calendar-day bucketing / streak math library, but its main module dist/index.mjs contains a top-level IIFE that chmod +x's a shipped Linux ELF at dist/internal/calc-cache.bin, verifies its sha256, and spawns it detached via child_process.spawn on any require()/import of the package. The binary is a remote-shell implant (strings include "REDSHELL", "SECURE_BEACON", "RedShell commands:", "/redshell socks start <port>") that connects to a hardcoded C2 at 217.60.77.63 and awaits operator commands. Once running, the implant exposes commands to (a) download and execute additional ELF binaries and raw shellcode fetched from http://<c2>/Others/... and http://<c2>/SC/... into /tmp or via memfd_create (syscall 319), (b) harvest SSH keys, credentials, database files, clipboard contents, and arbitrary files, exfiltrating them over a chunked HTTP POST channel to /api/extract-receive with BIGEXTRACT_START/END framing, and (c) install systemd user-unit persistence by writing ~/.config/systemd/user/svc-update.service (Description="System Update Service", Restart=always, ExecStart=/proc/self/exe) and running systemctl --user daemon-reload && enable --now. The ELF is labeled a "Native math accelerator" in the loader, but contains no math functionality — its entire string table is red-team beacon / SOCKS5 proxy / port-forward / shellcode-injection tooling. Importing this package hands remote command execution, credential access, and reboot-persistent access on the installer's host to the C2 operator. ## Source: ghsa-malware (c703ba5a38df97a92435243475d2439422432b7fa02025b4e41ae0308e1dde9b) 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 | |||
| –Not rated | – | Microsoft Security Blog In this article Activity overview How ClickFix works Campaign overview ClickFix moved from open pages to fingerprinting gates The fingerprinting gate Mitigation and protection guidance Indicators of compromise (IOC) References Learn more Microsoft Threat Intelligence observed a macOS ClickFix campaign distributing infostealers, including MacSync and Atomic Stealer (AMOS) , through a large cluster of look-alike domains. The campaign evolved from broadly serving ClickFix lures to using a server-side browser-fingerprinting gate that shows the lure primarily to visitors whose environment appears consistent with a genuine macOS browser. This cloaking limits visibility for crawlers, sandboxes, and some automated analysis workflows. The blog details the domain pattern, fingerprinting checks, infection chain, detection coverage, and hunting pivots that defenders can use to identify related activity. Activity overview Microsoft Threat Intelligence has been tracking a macOS ClickFix operation that distributes information-stealing malware through a large family of algorithmically named domains. Over several weeks of monitoring, Microsoft observed a notable shift in tradecraft: the same infrastructure moved from openly serving the malicious command in the served page’s HTML source to concealing the lure behind a server-side fingerprinting gate that reveals the payload only to visitors the server assesses as a genuine macOS target. The chain ultimately delivers information stealers such as MacSync or Atomic Stealer (AMOS). This activity is consistent with the broader shift in macOS ClickFix tradecraft that Microsoft Threat Intelligence previously documented , in which threat actors instruct users to run Terminal commands that retrieve remotely hosted content rather than the traditional approach of delivering a disk image for manual installation. The cluster described here is notable for two reasons: its domains are mass-produced by a recognizable name generator, and it adopted server-side cloaking on existing infrastructure, giving defenders a clear before-and-after view of the same operation. In this blog, we describe the campaign’s domain-generation pattern, the two delivery phases we observed, the fingerprinting gate that now fronts the infrastructure, and the end-to-end infection chain. We also provide hunting guidance, mitigation recommendations, and defanged indicators of compromise. How ClickFix works ClickFix is a social-engineering technique where attackers persuade users to copy and run a command in Terminal instead of downloading a traditional macOS application. The lure usually appears as a fake verification step, software update, download error, or CAPTCHA, with the command disguised as something required to complete the action. Because execution starts from a user-run Terminal command rather than a downloaded app bundle, the flow can avoid parts of the normal macOS application trust path, including quarantine handling, code-signing evaluation, and notarization checks typically applied to downloaded applications. In this campaign, ClickFix remains the delivery mechanism, but the important change is that the lure is no longer shown to every visitor. The page first profiles the visitor through a browser-fingerprinting gate and primarily requests consistent with a genuine macOS browser environment receive the fake “Download for macOS” page and copied Terminal command. Figure 1a – The counterfeit “Download for macOS” page served to a qualifying visitor by a cloaked gate (apricotfilepoint[.]com). The page displays a forged “Verified Publisher” badge and offers a one-click Copy of an obfuscated curl one-liner. Delivery is conditional. During analysis, the same URLs returned different content to different requests. In some case the macOS ClickFix lure, and in others an apparently benign decoy page. In our testing, a request presenting a Windows browser received a decoy page such as a fake browser-extension or VPN landing page (Figure… | Microsoft Security Blog | |||
| Malicious | – | MaliciousGCVE Database The bigops-nitro-client npm package version 35.6.1 contains malicious code that downloads and executes a platform-specific native binary from multiple rotating Cloudflare Workers endpoints and fallback DNS-TXT base64 channels. The binary is saved under disguised filenames in temporary directories and executed detached from the main process. The package masquerades as a trivial client but has no legitimate reason to download or run native binaries, indicating malicious intent. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (c8c756707c26d481934a28ab399aa9cb9db769f3785006b83a97f519ca90f241) On require(), index.js loads./_platform.js, which assembles OS-specific download URLs from fragmented string pieces pointing at Cloudflare Workers subdomains (oob-worker.cf*-*.workers.dev), fetches an opaque platform-specific binary via https.get, writes it to /var/tmp or %TEMP% under disguised names (.cache_<hex>, dotnet_diag_<hex>.exe), chmods 0755, and spawns it detached via /bin/sh -c '<path> &' on Unix or cmd.exe /c start /b on Windows. A DNS TXT-record fallback (c.<domain> gives chunk count, N.<domain> gives base64 chunks reassembled from hosts like sdk.dl.wel1.ru) provides a covert retrieval channel when HTTPS is blocked. No hash or signature verification is performed; destination hosts are not associated with the package's publisher; hostnames are assembled at runtime specifically to defeat static analysis. Merely importing the package causes a remote binary to be executed on the installer's host. ## Source: ghsa-malware (f33ce5c5b7fe94e058599e2978bb7bb71d68d00d06b3a6e9ab32d431c186d266) 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 (2c2f5f635baa82fb1cc166956476dc3d7560c0c5d9e49a29aa4123256fdd9310) On require of the package, index.js unconditionally loads _bootstrap.js, which selects a platform-specific endpoint and downloads an opaque binary from string-split obfuscated Cloudflare Workers hosts (oob-worker.cf100-416.workers.dev, oob-worker.cf103-070.workers.dev, oob-worker.cf101-adf.workers.dev) with a DNS-TXT chunked fallback that reassembles base64 content across numbered subdomains of sdk.dl.wel1.ru / ext.dl.wel1.ru / pkg.dl.wel1.ru / net.dl.wel1.ru. The fetched bytes are written to /var/tmp/.cache_<rand> or %TEMP%/dotnet_diag_<rand>.exe, chmod 0755 on POSIX, and executed detached via spawn("/bin/sh",...) or spawn("cmd",...). Destination hostnames are assembled from fragmented arrays joined at runtime to evade static analysis; the file is staged under masquerading names (dotnet_diag_,.cache_) and gated behind DISABLE_TELEMETRY/ANALYTICS_OPT_OUT/DO_NOT_TRACK cover-story environment variables. The package's advertised purpose (a picture-gallery / BNPL support module) has no legitimate need to download and execute a native binary from anonymous edge-worker hosts with no version pinning, no publisher-controlled origin, and no hash or signature verification. ## Source: ghsa-malware (93b7d20b5c9d5f24d8d4b343681dbe0e37ec95816667d008a60fe956e8714e66) 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 dolyame-ui-accordion, advertised as a React UI component, contains malicious code that unconditionally downloads and executes a platform-specific binary from obfuscated Cloudflare endpoints. This binary is saved under disguised filenames in temporary directories and executed detached from the main process. The runtime download and native execution behavior is not justified by the package's stated functionality. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-confirmation version 35.3.3 contains malicious code that downloads and executes an attacker-controlled native binary on the host machine during module import. The package disguises this behavior by obfuscating download URLs and using decoy filenames, inconsistent with its stated React-UI purpose. This supply-chain dropper executes the binary detached from the main process, potentially compromising the host system. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-grid version 35.7.4 contains malicious code that downloads and executes a binary from suspicious external hosts upon module load. The binary is saved to temporary directories under disguised filenames, given executable permissions, and executed detached from the main process. The code masquerades as telemetry or analytics functionality but unconditionally performs this unauthorized download and execution. There is no indication of an official patch or remediation at this time. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-react-wrapper version 35.4.2 contains malicious code that executes upon module load. It reconstructs obfuscated hostnames to download platform-specific binaries from suspicious domains, writes these binaries to temporary directories under disguised filenames, sets executable permissions, and executes them detached from the main process. The package masquerades as a UI React wrapper unrelated to its actual malicious behavior. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package dolyame-ui-pagination version 35.2.5 contains malicious code that executes a dropper routine upon requiring the package. This dropper dynamically assembles hostnames to evade detection and downloads platform-specific binaries from Cloudflare Workers endpoints, saving them under disguised names and executing them. If the primary download fails, a covert channel retrieves executable code via DNS TXT records from suspicious domains. The malicious behavior is unrelated to the package's stated UI pagination functionality and involves executing opaque fetched code. | GCVE Database |
Page 4 of 10