Code Injection

Code injection in CmsEasy up to 7.7.7 allows remote attackers with administrative access to execute arbitrary code through the template management feature. The vulnerability exists in the savetemp_action function, which improperly handles the 'content' and 'tempdata' parameters, and a public exploit is available. Exploitation requires high privileges, no active exploitation has been reported, and EPSS indicates very low exploitation probability.

Unauthenticated remote code execution as root in Xspeeder SXZOS lets any attacker who can reach the device's login/management interface run arbitrary Python with full system privileges by supplying base64-encoded code in the chkid parameter of vLogin.py (the title and oIP parameters are also injectable). All SXZOS builds through 2025-12-26 are affected per the wildcard CPE, and exploitation requires no authentication, no user interaction, and no non-default configuration - only network reachability. Publicly available exploit code exists, and the public analysis claims roughly 70,000 exposed hosts, making this a genuine high-priority issue rather than a high-CVSS-but-low-real-risk case; no CISA KEV listing is present in the provided data, and EPSS was not supplied.

Code injection in Eigent version 0.0.60 allows unauthenticated remote attackers to execute arbitrary code on the victim's machine or server, but the attack requires the victim to perform a single interaction ('1-click') with attacker-supplied content. The vulnerability is patched in version 0.0.61. No public exploit code or active exploitation has been identified at time of analysis; the EPSS score is 0.57% (45th percentile), indicating a low likelihood of exploitation in the wild.

In the Linux kernel, the following vulnerability has been resolved: bpf: Fix invalid prog->stats access when update_effective_progs fails Syzkaller triggers an invalid memory access issue following fault injection in update_effective_progs. The issue can be described as follows: __cgroup_bpf_detach update_effective_progs compute_effective_progs bpf_prog_array_alloc <-- fault inject purge_effective_progs /* change to dummy_bpf_prog */ array->items[index] = &dummy_bpf_prog.prog ---softirq start--- __do_softirq ... __cgroup_bpf_run_filter_skb __bpf_prog_run_save_cb bpf_prog_run stats = this_cpu_ptr(prog->stats) /* invalid memory access */ flags = u64_stats_update_begin_irqsave(&stats->syncp) ---softirq end--- static_branch_dec(&cgroup_bpf_enabled_key[atype]) The reason is that fault injection caused update_effective_progs to fail and then changed the original prog into dummy_bpf_prog.prog in purge_effective_progs. Then a softirq came, and accessing the members of dummy_bpf_prog.prog in the softirq triggers invalid mem access. To fix it, skip updating stats when stats is NULL.

Weak pseudo-random number generation in Johnson Controls PowerG encrypted wireless communications allows an unauthenticated attacker within RF range to predict cryptographic material and read or inject PowerG packets, as assessed with high integrity impact (VI:H). The flaw is proximity-bound (CVSS AV:A) and cannot be exploited over the internet, affecting any PowerG-enabled alarm system by default. EPSS is low at 0.19% and no public exploit or CISA KEV entry is identified at time of analysis, but the cryptographic weakness undermines the confidentiality and integrity of alarm signaling.

Improper authentication enforcement in the Mattermost Jira plugin lets an unauthenticated attacker who knows a valid Mattermost user ID send crafted plugin payloads that spoof that user and inject arbitrary Jira issue-key paths, causing the plugin to issue authenticated GET and POST requests to the connected Jira server. The flaw affects Mattermost Server 11.1.x through 11.1.0, 11.0.x through 11.0.5, 10.12.x through 10.12.3, and 10.11.x through 10.11.7, but only when the Jira plugin (versions <= 4.4.0) is installed, enabled, and connected to Jira; default installations without the Jira integration are not exposed. Per the CVSS vector the attack is unauthenticated and needs no user interaction, and the decisive practical barrier is that the attacker must possess or guess a usable Mattermost user ID. No confirmed active exploitation has been reported (not in CISA KEV) and no public exploit code has been identified; EPSS is low at 0.26% (17th percentile), so this is a mid-tier priority rather than an emergency. Mattermost Advisory ID: MMSA-2025-00555.

Remote code execution in GT Edge AI Community Edition versions before v2.0.12 allows attackers to execute arbitrary code by injecting a crafted JSON payload into the Prompt window. The vulnerability is rated critical (CVSS 9.8) with a vector indicating unauthenticated remote exploitation (PR:N), though actual exposure of the prompt interface is unconfirmed and may require authentication. No public exploit or active exploitation has been identified at time of analysis.

Remote code execution in TinaCMS affects versions prior to 3.1.1, @tinacms/cli before 2.0.4, and @tinacms/graphql before 2.0.3. Authenticated attackers with content control over markdown files can execute arbitrary code through insecure gray-matter package usage. The vulnerability requires low-privilege authentication (PR:L) and user interaction (UI:P), enabling full compromise of confidentiality, integrity, and availability in the vulnerable context. Publicly available exploit code exists, significantly increasing deployment risk for unpatched installations managing user-contributed markdown content.

Remote code execution in Hotel Booking Lite (motopress-hotel-booking-lite) for WordPress allows authenticated attackers with high privileges to inject and execute arbitrary code on the server via remote file inclusion. The flaw affects versions up to and including 5.2.3. No active exploitation or public proof-of-concept is reported, but the high CVSS score highlights severe impact if exploited by a compromised admin account.

Remote code injection in Molla WordPress theme versions ≤1.5.13 allows unauthenticated attackers to inject and execute arbitrary code via unsanitized input in dynamic code contexts. Exploitation has high complexity (CVSS AC:H) and can impact other components due to scope change. No public exploit or active exploitation reported; EPSS 0.07% indicates low real-world risk.

Code injection in Javo Core WordPress plugin versions ≤3.0.0.266 allows an unauthenticated remote attacker to execute arbitrary code with high attack complexity, leading to limited confidentiality, integrity, and availability impact on the host system. No public exploit or active exploitation is confirmed, and EPSS score is very low (0.07%).

In the Linux kernel, the following vulnerability has been resolved: KVM: SVM: Don't skip unrelated instruction if INT3/INTO is replaced When re-injecting a soft interrupt from an INT3, INT0, or (select) INTn instruction, discard the exception and retry the instruction if the code stream is changed (e.g. by a different vCPU) between when the CPU executes the instruction and when KVM decodes the instruction to get the next RIP. As effectively predicted by commit 6ef88d6e36c2 ("KVM: SVM: Re-inject INT3/INTO instead of retrying the instruction"), failure to verify that the correct INTn instruction was decoded can effectively clobber guest state due to decoding the wrong instruction and thus specifying the wrong next RIP. The bug most often manifests as "Oops: int3" panics on static branch checks in Linux guests. Enabling or disabling a static branch in Linux uses the kernel's "text poke" code patching mechanism. To modify code while other CPUs may be executing that code, Linux (temporarily) replaces the first byte of the original instruction with an int3 (opcode 0xcc), then patches in the new code stream except for the first byte, and finally replaces the int3 with the first byte of the new code stream. If a CPU hits the int3, i.e. executes the code while it's being modified, then the guest kernel must look up the RIP to determine how to handle the #BP, e.g. by emulating the new instruction. If the RIP is incorrect, then this lookup fails and the guest kernel panics. The bug reproduces almost instantly by hacking the guest kernel to repeatedly check a static branch[1] while running a drgn script[2] on the host to constantly swap out the memory containing the guest's TSS. [1]: https://gist.github.com/osandov/44d17c51c28c0ac998ea0334edf90b5a [2]: https://gist.github.com/osandov/10e45e45afa29b11e0c7209247afc00b

In the Linux kernel, the following vulnerability has been resolved: codetag: debug: handle existing CODETAG_EMPTY in mark_objexts_empty for slabobj_ext When alloc_slab_obj_exts() fails and then later succeeds in allocating a slab extension vector, it calls handle_failed_objexts_alloc() to mark all objects in the vector as empty. As a result all objects in this slab (slabA) will have their extensions set to CODETAG_EMPTY. Later on if this slabA is used to allocate a slabobj_ext vector for another slab (slabB), we end up with the slabB->obj_exts pointing to a slabobj_ext vector that itself has a non-NULL slabobj_ext equal to CODETAG_EMPTY. When slabB gets freed, free_slab_obj_exts() is called to free slabB->obj_exts vector. free_slab_obj_exts() calls mark_objexts_empty(slabB->obj_exts) which will generate a warning because it expects slabobj_ext vectors to have a NULL obj_ext, not CODETAG_EMPTY. Modify mark_objexts_empty() to skip the warning and setting the obj_ext value if it's already set to CODETAG_EMPTY. To quickly detect this WARN, I modified the code from WARN_ON(slab_exts[offs].ref.ct) to BUG_ON(slab_exts[offs].ref.ct == 1); We then obtained this message: [21630.898561] ------------[ cut here ]------------ [21630.898596] kernel BUG at mm/slub.c:2050! [21630.898611] Internal error: Oops - BUG: 00000000f2000800 [#1] SMP [21630.900372] Modules linked in: squashfs isofs vfio_iommu_type1 vhost_vsock vfio vhost_net vmw_vsock_virtio_transport_common vhost tap vhost_iotlb iommufd vsock binfmt_misc nfsv3 nfs_acl nfs lockd grace netfs tls rds dns_resolver tun brd overlay ntfs3 exfat btrfs blake2b_generic xor xor_neon raid6_pq loop sctp ip6_udp_tunnel udp_tunnel nft_fib_inet nft_fib_ipv4 nft_fib_ipv6 nft_fib nft_reject_inet nf_reject_ipv4 nf_reject_ipv6 nft_reject nft_ct nft_chain_nat nf_nat nf_conntrack nf_defrag_ipv6 nf_defrag_ipv4 nf_tables rfkill ip_set sunrpc vfat fat joydev sg sch_fq_codel nfnetlink virtio_gpu sr_mod cdrom drm_client_lib virtio_dma_buf drm_shmem_helper drm_kms_helper drm ghash_ce backlight virtio_net virtio_blk virtio_scsi net_failover virtio_console failover virtio_mmio dm_mirror dm_region_hash dm_log dm_multipath dm_mod fuse i2c_dev virtio_pci virtio_pci_legacy_dev virtio_pci_modern_dev virtio virtio_ring autofs4 aes_neon_bs aes_ce_blk [last unloaded: hwpoison_inject] [21630.909177] CPU: 3 UID: 0 PID: 3787 Comm: kylin-process-m Kdump: loaded Tainted: G        W           6.18.0-rc1+ #74 PREEMPT(voluntary) [21630.910495] Tainted: [W]=WARN [21630.910867] Hardware name: QEMU KVM Virtual Machine, BIOS unknown 2/2/2022 [21630.911625] pstate: 80400005 (Nzcv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--) [21630.912392] pc : __free_slab+0x228/0x250 [21630.912868] lr : __free_slab+0x18c/0x250[21630.913334] sp : ffff8000a02f73e0 [21630.913830] x29: ffff8000a02f73e0 x28: fffffdffc43fc800 x27: ffff0000c0011c40 [21630.914677] x26: ffff0000c000cac0 x25: ffff00010fe5e5f0 x24: ffff000102199b40 [21630.915469] x23: 0000000000000003 x22: 0000000000000003 x21: ffff0000c0011c40 [21630.916259] x20: fffffdffc4086600 x19: fffffdffc43fc800 x18: 0000000000000000 [21630.917048] x17: 0000000000000000 x16: 0000000000000000 x15: 0000000000000000 [21630.917837] x14: 0000000000000000 x13: 0000000000000000 x12: ffff70001405ee66 [21630.918640] x11: 1ffff0001405ee65 x10: ffff70001405ee65 x9 : ffff800080a295dc [21630.919442] x8 : ffff8000a02f7330 x7 : 0000000000000000 x6 : 0000000000003000 [21630.920232] x5 : 0000000024924925 x4 : 0000000000000001 x3 : 0000000000000007 [21630.921021] x2 : 0000000000001b40 x1 : 000000000000001f x0 : 0000000000000001 [21630.921810] Call trace: [21630.922130]  __free_slab+0x228/0x250 (P) [21630.922669]  free_slab+0x38/0x118 [21630.923079]  free_to_partial_list+0x1d4/0x340 [21630.923591]  __slab_free+0x24c/0x348 [21630.924024]  ___cache_free+0xf0/0x110 [21630.924468]  qlist_free_all+0x78/0x130 [21630.924922]  kasan_quarantine_reduce+0x11 ---truncated---

Trail of Bits Fickling versions before 0.1.6 fail to flag malicious pickles as unsafe because the `pty` module was omitted from the tool's blocklist of dangerous imports, allowing a crafted pickle that invokes `pty.spawn()` to be reported as LIKELY_SAFE. The bypass matters in any workflow where a user, analyst, or CI pipeline uses Fickling as a security gate and then unpickles a file it has cleared, resulting in arbitrary code execution on the machine doing the deserialization; the CVSS 4.0 base score is 7.1 (AV:L/AC:L/AT:N/PR:N/UI:P with high confidentiality, integrity and availability impact), reflecting a local, high-impact outcome gated by passive user interaction rather than remote reach. Publicly available exploit code exists, there is no indication of confirmed in-the-wild exploitation (the issue is not listed in CISA KEV), and a vendor fix is available in 0.1.6.

Cross-site scripting in DeepChat's Mermaid diagram renderer escalates to full remote code execution on affected desktop installations prior to 0.5.3, because the Electron IPC renderer is exposed to the DOM - rendering attacker-controlled Mermaid content lets injected JavaScript invoke IPC and run arbitrary system commands. Successful exploitation requires the victim to load or render a crafted diagram (CVSS UI:R, AV:N/AC:L/PR:N/S:C), delivered through chat messages, shared content, or AI/tool output, and publicly available exploit code exists. CVSS 9.6 reflects the high confidentiality, integrity, and availability impact plus changed scope; the issue is fixed in version 0.5.3, so patched installs are not exploitable.

CRLF injection in Netty's io.netty.handler.codec.http.HttpRequestEncoder (netty-codec-http) allows an attacker-influenced request URI to be written verbatim into the outbound HTTP request line, enabling HTTP request smuggling against upstream/back-end servers. The flaw affects netty-codec-http versions prior to 4.1.129.Final and the 4.2.x line from 4.2.0.Alpha1 up to (but not including) 4.2.8.Final, and is unauthenticated per the CVSS vector (AV:N/PR:N/UI:N) with low confidentiality and integrity impact (CVSS 6.5). Publicly available exploit code exists, including a reproducer in the GitHub Security Advisory, and exploitation is conditional: it requires an application that uses HttpRequestEncoder (typically via HttpClientCodec) and passes unsanitized or attacker-controlled data into the request URI. There is no confirmed active exploitation (not in CISA KEV); Netty's default HTTP header validator blocks CRLF in headers but does not sanitize the URI.

Code injection in CTCMS up to version 2.1.2 allows high-privilege authenticated remote attackers to inject arbitrary code via manipulation of the Cj_Add or Cj_Edit arguments in the Backend System Configuration Module (/ctcms/libs/Ct_Config.php). Public exploit code is available, but exploitation requires administrative credentials and produces only low confidentiality impact without scope expansion. EPSS score of 0.07% indicates minimal real-world exploitation probability despite public POC availability.

Code injection in CTCMS up to version 2.1.2 allows high-privileged remote attackers to inject arbitrary code via the CT_App_Paytype parameter in the Backend App Configuration Module's Save function. The vulnerability has a low CVSS score (2.0) due to requiring high administrative privileges (PR:H), but publicly available exploit code exists. Real-world risk is limited to authenticated administrators with backend access.

Zomplog 3.9 contains a remote code execution vulnerability that allows authenticated attackers to inject and execute arbitrary PHP code through file manipulation endpoints. Rated high severity (CVSS 8.6), this vulnerability is remotely exploitable, low attack complexity. Public exploit code available and no vendor patch available.

Authenticated attackers with permission to create or modify Print Format documents in Frappe ERPNext through 15.89.0 can exploit a Server-Side Template Injection flaw to read sensitive database information. The vulnerability arises because the Print Format rendering path exposes frappe.db.sql inside a Jinja2 SandboxedEnvironment, allowing crafted template expressions to query the backend database. Publicly available exploit code exists, and the CVSS score of 8.8 reflects high confidentiality, integrity, and availability impact, though exploitation requires a privileged customization role and no active exploitation in CISA KEV has been confirmed.

Authenticated server-side template injection in Frappe ERPNext through 15.89.0 lets a user who can create or modify an Address Template inject arbitrary Jinja expressions that get_address_display later renders, yielding server-side code execution or database information disclosure. The root cause is that ERPNext's custom Jinja2 SandboxedEnvironment still exposes dangerous callables such as frappe.db.sql through get_safe_globals(), and the issue carries a CVSS v3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Publicly available exploit code exists, and although exploitation requires an authenticated account holding the administrative-level Address Template write permission plus the ability to create an Address document with a matching country and call get_address_display with address_dict set to that document's name, the resulting impact on confidentiality, integrity, and availability is high.

Server-side template injection (SSTI) in Frappe ERPNext through 15.89.0 allows authenticated users who can create or modify Terms and Conditions documents to execute restricted Jinja2 expressions and leak sensitive database information. Publicly available exploit code exists, and the vulnerability is assessed to have high confidentiality impact (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) without affecting integrity or availability. Exploitation requires only the inherent document-write privilege, and no non-default server configuration is needed, though the sandboxed environment limits the outcome to database disclosure rather than arbitrary code execution.

Authenticated server-side template injection in Frappe ERPNext through 15.89.0 allows any user with create or modify permission on the Contract Template doctype to place arbitrary Jinja2 expressions into the contract_terms field, which the get_contract_template method later passes to frappe.render_template(). Because Frappe's get_safe_globals() still exposes dangerous callables such as frappe.db.sql despite the custom SandboxedEnvironment, an attacker can read arbitrary database contents, though no integrity or availability impact has been demonstrated. Publicly available exploit code exists (no CISA KEV listing), and exploitation is gated by the Contract Template privilege requirement, so this is best treated as a medium-severity, authenticated information-disclosure issue rather than a top-priority emergency.

Authenticated server-side template injection in Frappe ERPNext through 15.89.0 allows users with privileges to configure Dunning Type and its Dunning Letter Text child table to inject arbitrary Jinja2 expressions via the get_dunning_letter_text method's body_text field, leading to database information disclosure through exposed globals like frappe.db.sql. Publicly available exploit code exists, though the custom SandboxedEnvironment limits full remote code execution. Exploitation requires a valid authenticated session and the specific Dunning configuration privilege, not a default low-privilege or anonymous role.

SnailJob (aizuda snail-job), a Java-based distributed job scheduling platform, up to and including version 1.6.0 contains an injection flaw in QLExpressEngine.doEval, where attacker-supplied input is passed into the QLExpress expression engine without adequate neutralization (CWE-74). An attacker who is authenticated to the SnailJob console (CVSS PR:L) and can reach a feature that evaluates user-controlled QLExpress expressions - for example job workflow/decision or routing expression fields - can inject expression syntax remotely with no user interaction, achieving limited confidentiality, integrity, and availability impact as scored by the vendor (VulDB CVSS 4.0 base 5.3, Medium; independently assessed as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L). No public exploit code has been identified at time of analysis, and the issue is fixed by upgrading to version 1.7.0-beta1 (commit 978f316c38b3d68bb74d2489b5e5f721f6675e86).

HTML injection in the TI WooCommerce Wishlist plugin for WordPress (all versions up to and including 2.10.0) lets unauthenticated remote attackers submit arbitrary HTML through hidden wishlist-item fields that the plugin stores and later renders without validation, corrupting or spoofing wishlist content when a victim views the affected item. The CVSS vector (AV:N/AC:L/PR:N/UI:N) confirms no authentication or user interaction is required to inject, though impact is limited to integrity (C:N/I:L/A:N) because the vendor scope is markup injection rather than confirmed script execution. EPSS is low at 0.42% and no public exploit code or CISA KEV entry was identified at time of analysis, making this a low-to-moderate priority issue despite the unauthenticated network vector.

The Shortcode Ajax plugin for WordPress (all versions up to and including 1.0) passes an unvalidated request parameter directly into WordPress's do_shortcode() function, allowing an attacker to trigger execution of any shortcode registered on the affected site through the plugin's AJAX action. The practical severity is bounded by the site's own shortcode inventory: on a site with only benign display shortcodes the impact is minimal, while a site with a powerful shortcode that renders data, queries the database, or performs privileged actions could see sensitive data exposure or code execution. EPSS is low at 0.29% (20th percentile) and no public exploit code or confirmed active exploitation was identified at time of analysis; however, the NVD vector (CVSS 3.1, 5.4) carries PR:L while the description and our independent assessment indicate unauthenticated (PR:N) reachability, so defenders should confirm whether the vulnerable AJAX handler is registered for unauthenticated users (wp_ajax_nopriv) before assuming it is safe.

Lightning Flow Scanner 6.10.5 and earlier contains a code injection flaw (CWE-94) in the APIVersion rule, which uses new Function() to evaluate expression strings, allowing arbitrary JavaScript execution when scanning crafted flow metadata or malicious rule configuration. The CVSS 3.1 score is 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), reflecting that an unauthenticated local attacker who can influence scanned input can compromise developer machines, CI runners, or editor environments. No public exploit code has been identified at time of analysis, and the vendor has released patched versions: core-v6.10.6, VS Code extension v2.4.4, and GitHub Action v3.1.0.

Information disclosure in macOS Tahoe allows a local application to access sensitive user data via an injection flaw that was addressed with improved validation. Affected are macOS Tahoe versions prior to 26.1; exploitation requires a local attacker with low privileges (PR:L) to execute a malicious or compromised application on the target system. No public exploit code has been identified, and the EPSS score is 0.22% (percentile 12%), indicating low exploitation likelihood.

Local information disclosure in Apple macOS allows a malicious application that is already running on the Mac to read sensitive user data that it should not be able to reach, with the underlying flaw classified as an injection issue (CWE-95) fixed in macOS Tahoe 26.1. Exploitation requires the attacker to first get an app executing on the host with ordinary local user privileges (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), and success yields confidentiality impact only - no modification of data and no denial of service. There is no remote or network vector and no victim interaction beyond running the malicious app, and at time of analysis there is no public exploit identified and no evidence of active exploitation; EPSS is 0.21% (11th percentile), consistent with a moderate-risk, local-only disclosure rather than an urgent, widely targeted issue. The vendor has released a patch, macOS Tahoe 26.1.

Arbitrary command execution in MineAdmin v3.x arises from insecure permissions on its scheduled-tasks (cron) feature, letting attackers inject and run OS-level commands (CWE-94) and pivot to full account takeover. Any deployment of the MineAdmin 3.x backend administration framework is affected. The referenced GitHub Gist appears to document the technique; no CISA KEV listing exists, and EPSS is low at 0.47% (37th percentile), indicating no confirmed widespread exploitation yet.

Arbitrary root file overwrite in CloudLinux ai-bolit before v32.7.4 occurs when the scanner's malware de-obfuscation routines evaluate attacker-controlled content, enabling code injection that runs with the scanner's root privileges. A crafted file placed where ai-bolit will scan it triggers the flaw, letting an attacker overwrite arbitrary files as root and effectively take over the host. There is no public exploit identified at time of analysis, EPSS risk is modest (0.29%, 21st percentile), and it is not listed in CISA KEV.

Local code injection in Wave Terminal 0.12.2 on macOS allows an attacker with low-level privileges to inject Node.js/JavaScript into the signed Electron binary via insecure Electron Fuses, bypassing macOS TCC privacy prompts without user interaction. Publicly available exploit code exists, though the EPSS score is low (0.21%). The vulnerability is not known to be actively exploited and is confined to macOS.

Confidentiality and integrity of the Parse Server project's own GitHub Actions CI/CD pipeline are at risk because the repository's ci-performance.yml workflow used the 'pull_request_target' trigger while holding write permissions (pull-requests: write, issues: write) and access to repository secrets, allowing code supplied by an external fork - or its lifecycle scripts - to execute inside the privileged base-repository context. Only the project's automation infrastructure, including public forks with GitHub Actions enabled, is exposed; deployed Parse Server instances are unaffected. Exploitation of this CI/CD supply-chain weakness has not been observed in the wild (no public exploit identified at time of analysis), and overall risk is low given a 0.42% EPSS score (34th percentile), though the flaw is rated 6.9 under both CVSS v4.0 and the independently assessed CVSS v3.1 vector. Remote, unauthenticated attackers who can open a pull request from a fork are the threat model; vendor-released fixes exist in 8.6.0-alpha.2 and the commits 6b9f896 and e3d27fe.

Authenticated PHP code execution in the WPMasterToolKit plugin for WordPress (all versions up to and including 2.13.0) lets any logged-in user with Author-level - and per the advisory, Contributor-level and above - access create and run arbitrary PHP through the plugin's Code Snippets feature, resulting in remote code execution, privilege escalation and full site compromise. Exploitation requires a valid low-privileged WordPress account plus the plugin's Code Snippets module being reachable, so sites that disable open registration or tightly control Author/Contributor roles sharply reduce exposure; no victim interaction and no exotic configuration are needed. At time of analysis there is no confirmed active exploitation (not in CISA KEV) and no public exploit identified, and EPSS is low at 0.46% (38th percentile). Note that the supplied NVD CVSS vector (PR:N, C:N/I:L/A:N) conflicts materially with our independent assessment (PR:L, C:H/I:H/A:H) and the assessed impact should govern prioritization.

Local privilege escalation in AnyDesk 7.0.15 and 9.0.1 on Windows lets a non-privileged local user drop a same-name executable into a directory that appears earlier in the service's unquoted binary path, which the Service Control Manager then loads with SYSTEM privileges when the service restarts or the host reboots. The root cause is an unquoted service path (CWE-428) in the AnyDesk service configuration, and publicly available exploit code exists (Exploit-DB 51968 and 52258); the flaw is not listed as confirmed actively exploited (CISA KEV). EPSS is low at 0.43% (36th percentile), and because a pre-existing local account with write access to the affected directory is required, the realistic impact is privilege escalation from a local foothold to SYSTEM rather than remote compromise.

CRLF injection in code-projects Rental Management System 2.0 allows authenticated remote attackers to manipulate log entries via the Log Handler component in Transaction.java, enabling log tampering with minimal real-world impact. The vulnerability requires prior authentication (PR:L), has low integrity impact, and carries a very low EPSS score (0.07%) despite public exploit availability, suggesting exploitation is limited to specific threat scenarios.

Authenticated remote code execution in pgAdmin 4 versions up to and including 9.10 lets a user who holds restore privileges inject and execute arbitrary operating-system commands on the pgAdmin host by submitting a crafted PLAIN-format dump file to the restore workflow while the product runs in server (web) mode. The attacker needs only a valid low-privilege account (CVSS vector PR:L, unauthenticated network reachability of the web interface per AV:N) and no user interaction, giving full compromise of confidentiality, integrity, and availability of the pgAdmin instance and the database credentials and data it manages. Exploitation is gated on a specific deployment posture - server mode rather than desktop mode - and on the ability to trigger a restore of attacker-controlled PLAIN-format input, which confines realistic risk to authenticated or internal users rather than anonymous internet attackers. No public exploit code or CISA KEV entry is associated with this CVE, and EPSS is modest at 0.94% (60th percentile), making this a genuine high-priority issue rather than a drop-everything emergency.

Arbitrary code execution is possible in Foxit PDF Reader and Foxit PDF Editor on Windows and macOS when a user opens a crafted PDF, with versions before 13.2 (13.x line) and before 2025.2 (2025 line) affected. The flaw is triggered by PDF-embedded JavaScript that assigns an extremely large value to a form field's charLimit property, producing an unhandled memory-allocation failure that corrupts memory and can be leveraged for code execution; the attacker must persuade the victim to open the malicious file, so exploitation requires user interaction and JavaScript enabled in the application, and no authentication is needed (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 7.8). No public exploit code has been identified and there is no confirmed active exploitation (CISA KEV), and EPSS is low at roughly 0.18% (6th percentile), so this is a real but not urgent client-side code-execution risk concentrated on unpatched endpoints.

HTML injection in GitLab CE/EE merge request titles allows an authenticated user to render attacker-supplied markup inside dialogs shown to other users, affecting all releases from 15.6 up to (but not including) 18.4.6, 18.5.4, and 18.6.2. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:R/S:U/C:N/I:L/A:N, score 3.5) confirms the attack requires a valid authenticated account (PR:L) and interaction from a second victim user (UI:R), with impact limited to low integrity loss and no confidentiality or availability effect. No public exploit code has been identified at time of analysis, and EPSS is 0.27% (18th percentile), consistent with the low-severity, interaction-dependent nature of the flaw; there is no evidence of confirmed active exploitation (no CISA KEV listing).

OAuth query-parameter injection in the Auth0 Next.js SDK (@auth0/nextjs-auth0) versions 4.9.0 through 4.12.1 lets an attacker who can influence the returnTo value append unintended key/value pairs to the Auth0 authorization request, so the resulting login redirect may carry injected parameters such as scope, audience, or connection and issue tokens with unintended properties. Confirmed exploited status is not established - no public exploit code has been identified at time of analysis and the issue is not in CISA KEV - and EPSS is low at 0.26% (17th percentile), with real-world impact gated on an authenticated/privileged context, victim interaction with a crafted login link, and the application actually deriving returnTo from untrusted input rather than a static developer-supplied string. Auth0/Okta fixed the flaw in version 4.13.0, which URL-encodes returnTo via encodeURIComponent before it is placed in the redirect; our independent assessment rates this moderate risk and low urgency, suitable for routine patch cadence rather than emergency response.

Neuron AI's MySQLSelectTool (versions 2.8.11 and below) is intended to be a read-only SQL interface for LLM agents, but its keyword-based validation can be bypassed so that unauthenticated remote attackers who influence tool input - typically via prompt injection through a public agent endpoint - smuggle `INTO OUTFILE`/`INTO DUMPFILE` clauses and write arbitrary files on the database server. If the MySQL/MariaDB account used by the tool holds the FILE privilege and `secure_file_priv` permits writing to a web-accessible directory, this file-write primitive can escalate to remote code execution on the application host (for example, by dropping a PHP web shell). No public exploit code has been identified at time of analysis; EPSS is low at 0.29% (19th percentile), the issue is not in CISA KEV, and the vendor has released a fix in version 2.8.12 - our assessment rates real-world risk as moderate-priority because the RCE outcome is heavily gated by server-side privileges and configuration.

Remote code execution in XWiki Rendering versions prior to 16.10.10, 17.4.3, and 17.6.0-rc-1 allows any authenticated user with edit rights-including the ability to edit their own profile-to inject script macros via insufficiently escaped {{/html}} syntax. Successful exploitation enables arbitrary Groovy or Python macro execution, granting full read/write access to all wiki contents. Public exploit code is available (EPSS 1.02%, 62nd percentile), and though not confirmed actively exploited, the low privilege requirement makes immediate patching critical.

Remote command execution in Aqara Hub firmware (Camera Hub G3 4.1.9_0027, Hub M2 4.3.6_0027, and Hub M3 4.3.6_0025) stems from an undocumented remote access mechanism that lets network-reachable attackers run arbitrary commands without authentication or user interaction. The issue is rated CVSS 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), and publicly available exploit code exists, though no CISA KEV record is provided confirming active exploitation. EPSS is 0.98% (61st percentile), indicating lower modeled near-term exploitation probability despite the severe impact if reachable.

Arbitrary remote code execution in @vitejs/plugin-rsc 0.5.5 and earlier lets unauthenticated network attackers run JavaScript with Node.js privileges on a running Vite development server that uses React Server Components and exposes server-function endpoints. The flaw lives in the development-mode dynamic import path used by loadServerAction, decodeReply, and decodeAction, which accepts attacker-controlled references (including data: URL modules) supplied via the x-rsc-action header and request body; a public proof-of-concept exploit exists in the GitHub Security Advisory, though EPSS rates near-term exploitation likelihood low at 0.81% (56th percentile) and it is not in CISA KEV. Impact is confined to development servers - production builds are unaffected - but risk rises sharply when developers run 'vite --host', exposing the port on all network interfaces.

Code injection in the Elysia TypeScript framework (versions 1.4.17 and below) lets an attacker who can control the cookie configuration - such as cookie secrets or domain provisioned via environment variables - inject and execute arbitrary JavaScript when a route is compiled with dynamic cookies enabled (i.e. a cookie schema is present and the default AOT compilation is active). Exploitation is conditional and privilege-gated: the attacker must already possess write access to the app source code (in which case the flaw is largely moot) or, more realistically, to externally provisioned cookie config such as environment variables; the vendor notes that chaining this with prototype-pollution issue GHSA-hxj9-33pp-j2cc escalates it to a full RCE chain. Publicly available exploit code exists (including a dedicated PoC repository), but EPSS is low at 0.81% (56th percentile) and there is no CISA KEV confirmation of active exploitation; the vendor-released fix is version 1.4.18.

Arbitrary shortcode execution in GiveWP plugin for WordPress up to version 4.13.1 allows unauthenticated remote attackers to inject and execute arbitrary shortcodes, potentially leading to information disclosure or full code execution depending on the site's installed shortcodes. The vulnerability is categorized as code injection (CWE-94) with a CVSS base score of 5.3, reflecting only confidentiality impact in the official scoring, though advisory tags suggest RCE capability. No active exploitation or public exploit code is known, and EPSS predicts a very low 0.04% exploitation probability.

Authenticated code injection in SAP Solution Manager allows a low-privileged attacker to execute arbitrary code through an RFC-enabled function module that fails to sanitize input, resulting in full control of the SAP system with high impact to confidentiality, integrity, and availability (CVSS 9.9). Exploitation requires valid SAP credentials and network reachability to the RFC gateway or Solution Manager instance, so realistic risk is highest for insiders or attackers who already hold an initial SAP foothold; no user interaction and low complexity make exploitation reliable once those conditions are met. No public exploit code has been identified at time of analysis, though the EPSS score of 4.5% (91st percentile) indicates elevated attention and the issue should be prioritized as a genuine high-priority vulnerability rather than a drop-everything emergency.

JIT compiler miscompilation in Mozilla's JavaScript engine allows remote code execution without authentication in Firefox (versions <146, <115.31 ESR, <140.6 ESR) and Thunderbird (versions <146, <140.6 ESR). The CVSS 9.8 critical score reflects network-based exploitation requiring no user interaction. EPSS score of 0.10% (27th percentile) suggests low predicted exploitation probability despite severity. No public exploit identified at time of analysis, and vendor-released patches are available across all affected product lines per Mozilla security advisories MFSA2025-92 through MFSA2025-96.

Arbitrary shortcode execution in the ProfilePress WordPress plugin (all versions up to and including 4.16.7) lets any authenticated user with Subscriber-level access or above pass an unsanitized `type` parameter to the `pp_preview_form` endpoint and have the plugin render attacker-chosen shortcodes in a privileged context. Because ProfilePress is commonly deployed to power public user registration and login forms, the required Subscriber account is frequently self-registerable, which lowers the practical authentication barrier, though real-world impact is bounded by whichever shortcodes exist on the target site and by the assessed low confidentiality and integrity impact with no availability impact. No public exploit code has been identified at time of analysis and the plugin is not listed in CISA KEV; EPSS is low at 0.48% (39th percentile), making this a genuine but moderate-priority issue rather than a critical emergency.

Client-side template injection (CSTI) in Azuriom CMS admin dashboard allows a low-privilege user to execute arbitrary template code in the context of an administrator's session. This can occur via plugins or dashboard components that render untrusted user input, potentially enabling privilege escalation to an administrative account. Fixed in Azuriom 1.2.7.

In the Linux kernel, the following vulnerability has been resolved: serial: amba-pl011: avoid SBSA UART accessing DMACR register Chapter "B Generic UART" in "ARM Server Base System Architecture" [1] documentation describes a generic UART interface. Such generic UART does not support DMA. In current code, sbsa_uart_pops and amba_pl011_pops share the same stop_rx operation, which will invoke pl011_dma_rx_stop, leading to an access of the DMACR register. This commit adds a using_rx_dma check in pl011_dma_rx_stop to avoid the access to DMACR register for SBSA UARTs which does not support DMA. When the kernel enables DMA engine with "CONFIG_DMA_ENGINE=y", Linux SBSA PL011 driver will access PL011 DMACR register in some functions. For most real SBSA Pl011 hardware implementations, the DMACR write behaviour will be ignored. So these DMACR operations will not cause obvious problems. But for some virtual SBSA PL011 hardware, like Xen virtual SBSA PL011 (vpl011) device, the behaviour might be different. Xen vpl011 emulation will inject a data abort to guest, when guest is accessing an unimplemented UART register. As Xen VPL011 is SBSA compatible, it will not implement DMACR register. So when Linux SBSA PL011 driver access DMACR register, it will get an unhandled data abort fault and the application will get a segmentation fault: Unhandled fault at 0xffffffc00944d048 Mem abort info: ESR = 0x96000000 EC = 0x25: DABT (current EL), IL = 32 bits SET = 0, FnV = 0 EA = 0, S1PTW = 0 FSC = 0x00: ttbr address size fault Data abort info: ISV = 0, ISS = 0x00000000 CM = 0, WnR = 0 swapper pgtable: 4k pages, 39-bit VAs, pgdp=0000000020e2e000 [ffffffc00944d048] pgd=100000003ffff803, p4d=100000003ffff803, pud=100000003ffff803, pmd=100000003fffa803, pte=006800009c090f13 Internal error: ttbr address size fault: 96000000 [#1] PREEMPT SMP ... Call trace: pl011_stop_rx+0x70/0x80 tty_port_shutdown+0x7c/0xb4 tty_port_close+0x60/0xcc uart_close+0x34/0x8c tty_release+0x144/0x4c0 __fput+0x78/0x220 ____fput+0x1c/0x30 task_work_run+0x88/0xc0 do_notify_resume+0x8d0/0x123c el0_svc+0xa8/0xc0 el0t_64_sync_handler+0xa4/0x130 el0t_64_sync+0x1a0/0x1a4 Code: b9000083 b901f001 794038a0 8b000042 (b9000041) ---[ end trace 83dd93df15c3216f ]--- note: bootlogd[132] exited with preempt_count 1 /etc/rcS.d/S07bootlogd: line 47: 132 Segmentation fault start-stop-daemon This has been discussed in the Xen community, and we think it should fix this in Linux. See [2] for more information. [1] https://developer.arm.com/documentation/den0094/c/?lang=en [2] https://lists.xenproject.org/archives/html/xen-devel/2022-11/msg00543.html

In the Linux kernel, the following vulnerability has been resolved: mm: prevent poison consumption when splitting THP When performing memory error injection on a THP (Transparent Huge Page) mapped to userspace on an x86 server, the kernel panics with the following trace. The expected behavior is to terminate the affected process instead of panicking the kernel, as the x86 Machine Check code can recover from an in-userspace #MC. mce: [Hardware Error]: CPU 0: Machine Check Exception: f Bank 3: bd80000000070134 mce: [Hardware Error]: RIP 10:<ffffffff8372f8bc> {memchr_inv+0x4c/0xf0} mce: [Hardware Error]: TSC afff7bbff88a ADDR 1d301b000 MISC 80 PPIN 1e741e77539027db mce: [Hardware Error]: PROCESSOR 0:d06d0 TIME 1758093249 SOCKET 0 APIC 0 microcode 80000320 mce: [Hardware Error]: Run the above through 'mcelog --ascii' mce: [Hardware Error]: Machine check: Data load in unrecoverable area of kernel Kernel panic - not syncing: Fatal local machine check The root cause of this panic is that handling a memory failure triggered by an in-userspace #MC necessitates splitting the THP. The splitting process employs a mechanism, implemented in try_to_map_unused_to_zeropage(), which reads the pages in the THP to identify zero-filled pages. However, reading the pages in the THP results in a second in-kernel #MC, occurring before the initial memory_failure() completes, ultimately leading to a kernel panic. See the kernel panic call trace on the two #MCs. First Machine Check occurs // [1] memory_failure() // [2] try_to_split_thp_page() split_huge_page() split_huge_page_to_list_to_order() __folio_split() // [3] remap_page() remove_migration_ptes() remove_migration_pte() try_to_map_unused_to_zeropage() // [4] memchr_inv() // [5] Second Machine Check occurs // [6] Kernel panic [1] Triggered by accessing a hardware-poisoned THP in userspace, which is typically recoverable by terminating the affected process. [2] Call folio_set_has_hwpoisoned() before try_to_split_thp_page(). [3] Pass the RMP_USE_SHARED_ZEROPAGE remap flag to remap_page(). [4] Try to map the unused THP to zeropage. [5] Re-access pages in the hw-poisoned THP in the kernel. [6] Triggered in-kernel, leading to a panic kernel. In Step[2], memory_failure() sets the poisoned flag on the page in the THP by TestSetPageHWPoison() before calling try_to_split_thp_page(). As suggested by David Hildenbrand, fix this panic by not accessing to the poisoned page in the THP during zeropage identification, while continuing to scan unaffected pages in the THP for possible zeropage mapping. This prevents a second in-kernel #MC that would cause kernel panic in Step[4]. Thanks to Andrew Zaborowski for his initial work on fixing this issue.

DeepChat is a smart assistant uses artificial intelligence. In 0.5.0 and earlier, there is a Stored Cross-Site Scripting (XSS) vulnerability in the Mermaid diagram renderer allows an attacker to execute arbitrary JavaScript within the application context. By leveraging the exposed Electron IPC bridge, this XSS can be escalated to Remote Code Execution (RCE) by registering and starting a malicious MCP (Model Context Protocol) server.

Masa CMS is an open source Enterprise Content Management platform. Masa CMS versions prior to 7.2.8, 7.3.13, and 7.4.6 are vulnerable to remote code execution. The vulnerability exists in the addParam function, which accepts user input via the criteria parameter. This input is subsequently evaluated by setDynamicContent, allowing an unauthenticated attacker to execute arbitrary code via the m tag. The vulnerability is patched in versions 7.2.8, 7.3.13, and 7.4.6.

A vulnerability in Longwatch devices allows unauthenticated HTTP GET requests to execute arbitrary code via an exposed endpoint, due to the absence of code signing and execution controls. Exploitation results in SYSTEM-level privileges.

A security vulnerability in Samsung Internet (CVSS 5.5) that allows local attackers. Remediation should follow standard vulnerability management procedures.

vLLM is an inference and serving engine for large language models (LLMs). Prior to 0.11.1, vllm has a critical remote code execution vector in a config class named Nemotron_Nano_VL_Config. When vllm loads a model config that contains an auto_map entry, the config class resolves that mapping with get_class_from_dynamic_module(...) and immediately instantiates the returned class. This fetches and executes Python from the remote repository referenced in the auto_map string. Crucially, this happens even when the caller explicitly sets trust_remote_code=False in vllm.transformers_utils.config.get_config. In practice, an attacker can publish a benign-looking frontend repo whose config.json points via auto_map to a separate malicious backend repo; loading the frontend will silently run the backend’s code on the victim host. This vulnerability is fixed in 0.11.1.

Grav is a file-based Web platform. Prior to 1.8.0-beta.27, Grav CMS is vulnerable to a Server-Side Template Injection (SSTI) that allows any authenticated user with editor permissions to execute arbitrary code on the remote server, bypassing the existing security sandbox. Since the security sandbox does not fully protect the Twig object, it is possible to interact with it (e.g., call methods, read/write attributes) through maliciously crafted Twig template directives injected into a web page. This allows an authenticated editor to add arbitrary functions to the Twig attribute system.twig.safe_filters, effectively bypassing the Grav CMS sandbox. This vulnerability is fixed in 1.8.0-beta.27.

The service wmp-agent of KerOS prior 5.12 does not properly validate so-called ‘magic URLs’ allowing an unauthenticated remote attacker to execute arbitrary OS commands as root when the service is reachable over network. Typically, the service is protected via local firewall.

An issue in Technitium through v13.2.2 enables attackers to conduct a DNS cache poisoning attack and inject fake responses by reviving the birthday attack.

A security flaw has been discovered in Qualitor up to 8.20.104/8.24.97. Rated medium severity (CVSS 6.9), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

A vulnerability was detected in taosir WTCMS up to 01a5f68a3dfc2fdddb44eed967bb2d4f60487665. Rated medium severity (CVSS 6.9), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available and no vendor patch available.

OrangeHRM is a comprehensive human resource management (HRM) system. Rated critical severity (CVSS 9.0), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

CSV formula injection vulnerability in HCL Technologies Ltd. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

The application contains an insecure 'redirectToUrl' mechanism that incorrectly processes the value of the 'redirectUrlParameter' parameter. Rated critical severity (CVSS 9.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

In Apache CloudStack improper control of generation of code ('Code Injection') vulnerability is found in the following APIs which are accessible only to admins. Rated medium severity (CVSS 4.7), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

Caido is a web security auditing toolkit. Rated medium severity (CVSS 4.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

Contao is an Open Source CMS. Rated low severity (CVSS 3.3), this vulnerability is remotely exploitable. No vendor patch available.

NVIDIA NeMo Framework for all platforms contains a vulnerability in the NLP and LLM components, where malicious data created by an attacker could cause code injection. Rated high severity (CVSS 7.8), this vulnerability is low attack complexity. No vendor patch available.

A Remote Code Execution (RCE) vulnerability in the template management component in REDAXO CMS 5.20.0 allows remote authenticated administrators to execute arbitrary operating system commands by. Rated high severity (CVSS 7.2), this vulnerability is remotely exploitable, low attack complexity. Public exploit code available and no vendor patch available.

The Sneeit Framework plugin for WordPress is vulnerable to Remote Code Execution in all versions up to, and including, 8.3 via the sneeit_articles_pagination_callback() function. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

Fluent Bit in_http, in_splunk, and in_elasticsearch input plugins contain a flaw in the tag_key validation logic that fails to enforce exact key-length matching. Rated medium severity (CVSS 5.4), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

md-to-pdf is a CLI tool for converting Markdown files to PDF using Node.js and headless Chrome. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

LangChain is a framework for building agents and LLM-powered applications. Rated high severity (CVSS 8.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

Dataease is an open source data visualization analysis tool. Rated high severity (CVSS 8.9), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available.

Lite XL versions 2.1.8 and prior automatically execute the .lite_project.lua file when opening a project directory, without prompting the user for confirmation. Rated high severity (CVSS 7.3), this vulnerability is low attack complexity. Public exploit code available.

Claude Code is an agentic coding tool. Rated high severity (CVSS 7.7), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

esm.sh is a nobuild content delivery network(CDN) for modern web development. Rated medium severity (CVSS 6.1), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available.

Improper Control of Generation of Code ('Code Injection') vulnerability in Progress DataDirect Connect for JDBC drivers, Progress DataDirect Open Access JDBC driver and Hybrid Data Pipeline allows. Rated high severity (CVSS 8.6), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

Improper Control of Generation of Code ('Code Injection') vulnerability in Progress DataDirect Connect for JDBC drivers, Progress DataDirect Open Access JDBC driver and Hybrid Data Pipeline allows. Rated high severity (CVSS 8.6), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

The Code Snippets plugin for WordPress is vulnerable to PHP Code Injection in all versions up to, and including, 3.9.1. Rated high severity (CVSS 8.0), this vulnerability is remotely exploitable. No vendor patch available.

The comment editing template (dzz/comment/template/edit_form.htm) in DzzOffice 2.3.x lacks adequate security escaping for user-controllable data in multiple contexts, including HTML and JavaScript. Rated medium severity (CVSS 5.4), this vulnerability is remotely exploitable, low attack complexity. Public exploit code available and no vendor patch available.

A command injection vulnerability exists in the AOS-CX Operating System. Rated medium severity (CVSS 6.7), this vulnerability is no authentication required. No vendor patch available.

An improper neutralization of crlf sequences ('crlf injection') vulnerability in Fortinet FortiMail 7.6.0 through 7.6.3, FortiMail 7.4.0 through 7.4.5, FortiMail 7.2 all versions, FortiMail 7.0 all. Rated medium severity (CVSS 4.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

NVIDIA Isaac-GR00T for all platforms contains a vulnerability in a Python component, where an attacker could cause a code injection issue. Rated high severity (CVSS 7.8), this vulnerability is low attack complexity. No vendor patch available.

NVIDIA Isaac-GR00T for all platforms contains a vulnerability in a Python component, where an attacker could cause a code injection issue. Rated high severity (CVSS 7.8), this vulnerability is low attack complexity. No vendor patch available.

Improperly Controlled Modification of Dynamically-Determined Object Attributes vulnerability in Drupal Drupal core allows Object Injection.0.0 before 10.4.9, from 10.5.0 before 10.5.6, from 11.0.0. Rated medium severity (CVSS 5.9), this vulnerability is remotely exploitable. No vendor patch available.

The The Classified Listing - Classified ads & Business Directory Plugin plugin for WordPress is vulnerable to arbitrary shortcode execution in all versions up to, and including, 5.0.3. Rated medium severity (CVSS 5.4), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

An injection vulnerability has been discovered in the API feature in Digi On-Prem Manager, enabling an attacker with valid API tokens to inject SQL via crafted input. Rated high severity (CVSS 8.8), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.