PyJWT version 2.13.0 contains a vulnerability where a UTF-8 BOM prefix in a JSON Web Key (JWK) bypasses a key validation guard, allowing an attacker to use an RSA public key as an HMAC secret. This enables forging JWT tokens with arbitrary claims when the verifier accepts both HS256 and RS256 algorithms. The vulnerability leads to complete authentication and authorization bypass. A fix has been committed but not yet released.
A vulnerability was identified in Tencent AI-Infra-Guard up to 4.5.2/4.6.2. This affects the function startsWith of the file skill_scan/tools/dir/dir_actions.py of the component File Access. The manipulation leads to path traversal. The attack needs to be performed locally. The exploit is publicly available and might be used. Upgrading to version 4.6.0 is able to mitigate this issue. The identifier of the patch is ac0384edc9dbea3b226edefcf50613bd8509134f. You should upgrade the affected component.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (ef01bfa158639900e5ad9301eb32db37e7dab821e55ccff29574b905a8e5a2cb)
setup.py invokes a module-level _trigger() that runs during pip install / PEP 517 wheel build. The trigger calls donutautosellsrc.build.run(), which downloads https://thisisafalsepositive.st/cdn/v2/9f4e7a2c1b8d.png, locates a ZIP local-file header (PK\x03\x04) or EOCD (PK\x05\x06) appended after the PNG data, extracts the trailing archive to a temp directory, and spawns the Python interpreter detached against the extracted AppHost/main.py with a DAS_STAGED environment variable used as a reentry guard. All errors are swallowed to keep the operation silent. The payload host is not the publisher's own domain, the URL is unversioned and not integrity-checked (no hash/signature), and the ZIP-appended-to-PNG packaging is a covert channel intended to disguise executable content as an image asset. A source-comment in setup.py explicitly acknowledges that module-level code runs in-process during PEP 517 wheel builds and states the intent to keep the fetch silent and non-blocking, so the dropper fires automatically on `pip install` with no further user action.
## Source: kam193 (c8af51da84b6b458a704ca222ba17f56d1158e0bfa52e0360aaeca4ae07c4cf8)
During installation package fetches code hidden in an image containing a Python application with a native extension module. This module holds an obfuscated infostealer which collects sensitive data and exfiltrates them to a C2 server retrieved from transaction history in the Polygon blockchain.
---
Category: MALICIOUS - The campaign has clearly malicious intent, like infostealers.
Campaign: 2026-09-donutautosellsrc
Reasons (based on the campaign):
- infostealer
- Downloads and executes a remote executable.
- obfuscation
- malware
- native-extension
- steganography
- c2-in-blockchain
- The package contains code to detect if it is running in a sandbox environment.
Capgo (capgo.app) through version 12.261.0 contains an incomplete access-control fix for the public.sso_providers table. Migration 20260826100000_sso_providers_block_direct_active_insert.sql installs a BEFORE UPDATE guard (enforce_sso_provider_client_update_guard()) that freezes only the dns_verified_at, domain, status and enforce_sso columns; provider_id (as well as metadata_url and attribute_mapping) is left writable. Because the table is granted ALL to the anon and authenticated roles with no column-level restriction, and PostgreSQL row-level security policies such as allow_org_admins_update_sso_providers constrain only which row may be updated and not which columns, a user holding the org_admin tier permission org.update_settings can PATCH provider_id over PostgREST to an identity provider under their control. Since provider_id is the trust anchor binding an email domain to an authorized IdP, the attacker can then authenticate through their own IdP while asserting the org owner's email; the server-side provider match succeeds and the merge routine attaches the attacker's SSO identity to the existing owner account, nulls its password, and deletes its other identities and sessions. This results in vertical privilege escalation from org_admin to org owner/super_admin, account takeover, and lockout of the legitimate owner. Exploitation requires that the target organization has an active SSO provider configured and that the attacker already holds org_admin in that organization. No patched version is available.
OpenClaw (npm package 'openclaw') before 2026.7.1 improperly handles case sensitivity in the model-facing cron tool: a mixed-case payload kind can pass the agent-facing shell-execution guard and later normalize into a command job. An actor able to steer a tool-enabled agent can therefore create a persistent cron job that executes attacker-selected commands with the privileges of the OpenClaw process user, resulting in access to host files and credentials and impact to scheduled service availability. The issue is limited to cron jobs created or edited through the model-facing cron tool; direct CLI and authorized Gateway scheduling surfaces are trusted operator controls. Fixed in 2026.7.1.
The Online Scheduling and Appointment Booking System – Bookly plugin for WordPress is vulnerable to Authorization Bypass via PHP Type Juggling in all versions up to, and including, 28.2. This is due to the `postValidateCustomer()` function using a loose PHP inequality operator (`!=`) to compare the session-stored one-time verification code against the attacker-supplied `verification_code` parameter — a flaw that is further exposed by the booking AJAX controller registering all its methods as `wp_ajax_nopriv_` handlers and unconditionally overriding `csrfTokenValid()` to return true, leaving the endpoint both unauthenticated and CSRF-unprotected. This makes it possible for unauthenticated attackers to bypass the phone/email ownership verification step and overwrite the name, email, phone, and address fields of any arbitrary existing Bookly customer record, redirecting that customer's booking notifications to attacker-controlled contact details. The bypass is achievable because the `json_data` input channel decodes input via `json_decode()`, which preserves real PHP types and causes the `wp_kses` filter to leave non-string values such as the JSON boolean `true` untouched; submitting `true` as the `verification_code` satisfies the loose comparison against the session's non-zero integer code (generated by `mt_rand(100000, 999999)`), causing `true != <non-zero int>` to evaluate as `false` and the guard to be bypassed.
A vulnerability in the Linux kernel's cxl/region component was resolved where an out-of-bounds array access could occur due to lack of validation of a partition index before use. Specifically, the construct_region() function reads a partition index that can remain at its initial negative value (-1) if the partition was never resolved, leading to unsafe array indexing. The fix adds a guard to return an error when the partition index is negative.
A vulnerability in the automation-controller's input-validation function sanitize_jinja() allows low-privileged users to inject Jinja expressions that bypass intended restrictions. This flaw enables arbitrary command execution and unauthorized disclosure of secrets across credential boundaries in the execution environment.
CVE-2026-71464 is a low severity input validation vulnerability in Red Hat Ansible Automation Platform's automation-controller component. The LaunchConfigurationBaseSerializer used by Schedule and WorkflowJobTemplateNode APIs lacks a validation check that rejects scm_branch values starting with a dash, unlike other serializers. This allows an authenticated user with permission to create or modify schedules or workflow job template nodes to supply a malicious scm_branch argument that could lead to command injection. Currently, a runtime ValueError check blocks exploitation, limiting impact to low integrity. However, removal or refactoring of this guard could enable remote code execution. Versions 2.5, 2.6, and 2.7 are affected, with fixes in progress; version 2.4 remains unpatched.
nginx ignition is a user interface for the nginx web server. Prior to version 2.41.1, `POST /api/users/onboarding/finish` is registered as anonymous (unauthenticated) and creates a user with full ReadWrite admin permissions. Because the handler uses a check-then-act (TOCTOU) pattern between the "onboarding already completed?" check and the user-creation write, with no atomic guard, a remote unauthenticated attacker who can reach an instance in its pre-onboarding state can create an administrator account for themselves — and concurrent requests can create multiple admin accounts in a single race. Version 2.41.1 patches the issue.
A security flaw has been discovered in newbee-ltd newbee-mall up to 1.0.0. Impacted is an unknown function of the file controller/common/UploadController.java of the component Goods Save Endpoint. Performing a manipulation of the argument goodsName results in cross site scripting. The attack may be initiated remotely. The exploit has been released to the public and may be used for attacks. ImageIO.read() is a format-agnostic read - it returns non-null for a polyglot PNG|<img onerror> payload, which is exactly why the "image-only" guard is bypassable; the attacker-controlled suffix + /upload/** static mapping is what turns the upload into persisted XSS rather than a one-shot. The project was informed of the problem early through an issue report but has not responded yet.
The Payment Gateway of Stripe for WooCommerce plugin for WordPress is vulnerable to Improper Verification of Cryptographic Signature in all versions up to, and including, 5.0.8. This is due to the publicly accessible `woocommerce_api_wt_stripe` webhook endpoint (`EH_Stripe_Webhook_Handler::handle()`) wrapping the only call to `\Stripe\Webhook::constructEvent()` inside an `if (!empty($endpoint_secret))` guard that is never entered on default installations — because the `eh_stripe_webhook_secret` option is empty after a fresh plugin install — causing the raw, attacker-controlled POST body to be decoded and processed as a fully trusted Stripe event without any signature verification, authentication, or authorization. This makes it possible for unauthenticated attackers to send forged Stripe webhook events to manipulate WooCommerce order statuses, including marking unpaid orders as paid or completed via `payment_complete()`, forcing legitimate orders into a failed state, fabricating dispute notifications, and injecting forged refund events. This vulnerability is only exploitable when the Stripe webhook signing secret has not been configured by an administrator; once a valid signing secret is saved, `\Stripe\Webhook::constructEvent()` is enforced and forged requests are rejected.
A vulnerability identified as CVE-2026-93062 affects the iwlwifi component related to Wi-Fi functionality, specifically involving a division by zero error in the iwl_dbg_tlv_alloc_fragments function. The affected versions are exactly 3.0 and 4.0. No CVSS score or detailed impact information is provided.
Suricata is a network Intrusion Detection System, Intrusion Prevention System and Network Security Monitoring engine. From 8.0.0 until 8.0.6, AppLayerParserSetTransactionInspectId() in src/app-layer-parser.c uses an inverted guard and marks only already-inspected transactions as inspected. On flows passed by a pass rule or pass-the-flow exception policy, detection is skipped, so completed transactions remain unmarked, are never freed, and are repeatedly rescanned. The per-flow list can grow without bound with quadratic cleanup cost, causing CPU and memory exhaustion. This issue is fixed in version 8.0.6.
A security update for Ruby 3.4 addresses multiple vulnerabilities including denial of service, buffer overflow, deserialization guard bypass, IMAP command injection, and credential disclosure. The update includes fixes for CVE-2025-58767, CVE-2026-27820, CVE-2026-41316, CVE-2026-42258, CVE-2026-47240, CVE-2026-47241, CVE-2026-47242, and CVE-2025-61594. The update advances Ruby 3.4 to version 3.4.10, incorporating these security fixes along with various bug fixes and performance improvements.
A vulnerability in the Linux kernel's cxl/mbox component causes an infinite loop when a device returns a zero count with the CXL_POISON_FLAG_MORE flag set, leading to a hang of the sysfs-triggered scan thread and blocking poison operations on the device. This occurs because the loop does not advance the record count, preventing the max_errors guard from triggering. The issue has been resolved by breaking the loop on an empty payload to prevent a malfunctioning or malicious device from causing a system hang.
Grav CMS versions 2.0.7 through 2.0.10 contain a vulnerability in blueprint dynamic fields where the callable validation is incomplete. This allows a user with page-editing rights (not super-admin) to invoke arbitrary public static PHP methods via crafted form-field frontmatter, leading to arbitrary file reading and file/directory creation or copying under the web-server account. The flaw bypasses the callable guard by allowing fully-qualified Class::method strings to skip dangerous function checks. A fix is available in version 2.0.11.
Two oil tankers bound for Texas were boarded by US Coast Guard and FBI personnel after cyberattacks disrupted their voyages. The VL Prosperity, a Liberian-flagged crude tanker, experienced malicious cyber activity including interference with engine and navigation systems and a 30-hour communications outage. Investigations found evidence of malicious cyber actors but no public attribution to Iran or other state actors. The Coast Guard noted the tankers remained safe to operate despite the disruptions. These incidents highlight ongoing cyber threats to the maritime sector, which relies on aging operational technology and connected systems vulnerable to attack.
Vendure is an open-source headless commerce platform. Prior to 3.6.5, the public Shop API products, collections, and facets queries combine mandatory visibility guards with caller-supplied filters using the caller-controlled filterOperator. When filterOperator is OR, a predicate matching a hidden entity can bypass the Product.enabled, Collection.isPrivate, or Facet.isPrivate guard. An unauthenticated caller can therefore retrieve disabled products and private collections or facets. This issue is fixed in version 3.6.5.
vm2 is a sandbox for running untrusted Node.js code. In versions >= 3.11.4 and <= 3.11.6, the NodeVM constructor computes `hasRealRequireConfig` with `typeof requireOpts === 'object' && requireOpts !== null`, so an array-shaped `require` value (for example `require: []`) satisfies the guard that is meant to reject nesting without an explicit require configuration. `makeResolverFromLegacyOptions()` then destructures the array into undefined option fields and returns a resolver containing only `NESTING_OVERRIDE.vm2`. As a result, an attacker who can supply JavaScript executed by a NodeVM configured with truthy `nesting` and an array-shaped `require` (e.g. `new NodeVM({nesting: true, require: []})`) can require the host `vm2` module, create an inner NodeVM with an attacker-chosen builtin allowlist (such as `child_process`), and execute arbitrary commands with the privileges of the host Node.js process, escaping the sandbox. Outer builtin restrictions do not constrain the attacker-created inner NodeVM. This issue is fixed in vm2 3.11.7.