CVE-2026-118740: Patch the Aspire Dashboard Auth Bypass

Authorization gate protecting Aspire Dashboard telemetry streams from an unauthenticated missing-route request

Microsoft published guidance for CVE-2026-118740 on November 10, 2026, describing a critical authentication bypass in Aspire Dashboard. An unauthenticated request to a missing route can initialize dashboard UI infrastructure outside the expected authorization boundary. In both standalone and AppHost-hosted deployments, the flaw can permit telemetry deletion. In standalone deployments protected by browser-token authentication, it can also expose the browser token.

The fixed version is Aspire 13.6.5. Updating the .NET runtime or SDK alone is not sufficient because Aspire ships independently, and the running Dashboard may come from a container image, an AppHost SDK package, the Aspire CLI, or a custom path. Teams must identify the actual Dashboard binary or image selected at runtime, update that component, restart it, and verify that unauthenticated missing routes are redirected before dashboard infrastructure initializes.

What CVE-2026-118740 affects

Microsoft rates CVE-2026-118740 Critical with a CVSS 3.1 base score of 9.1. The advisory lists Aspire Dashboard and the platform-specific Aspire.Dashboard.Sdk packages earlier than 13.6.5 as affected. Microsoft specifically notes that versions 13.6.3 and 13.6.4 contain the unauthenticated NotFound route.

Deployment pathWhat to inspectFixed target
Standalone containermcr.microsoft.com/aspire/dashboard image tag or digest13.6.5 or later
AppHost with SDK packagesResolved Aspire.Dashboard.Sdk.* package13.6.5 or later
AppHost package referenceAspire.Hosting.AppHost or Aspire.AppHost.Sdk13.6.5 or later, then restore and rebuild
CLI-bundled DashboardDashboard bundled with the selected Aspire CLIA bundle containing 13.6.5 or later
Custom Dashboard pathThe executable selected by the custom path13.6.5 or later

The vulnerability is not limited to dashboards deliberately configured for anonymous access. The bypass concerns secured deployments whose missing-route flow failed to apply the normal authorization control. Anonymous mode remains risky for separate, documented reasons and should not be used on an untrusted network.

Why a missing route crossed the security boundary

Aspire Dashboard uses a routed frontend. The vulnerable NotFound path could render the main layout and supporting UI providers without first passing through the normal authorized route view. According to the fixing commit, that infrastructure included layout, interaction, dialog, and standalone terminal components.

The 13.6.5 fix moves the authorization decision in front of the missing-route content and adds defense-in-depth authentication checks before key UI infrastructure initializes. In browser-token mode, an unauthenticated request for a nonexistent path is redirected to the login page while preserving the original path as a local return URL.

This is operationally important because the Dashboard can display sensitive resource configuration, console output, logs, traces, metrics, and telemetry attributes. Standalone instances can also persist these records in SQLite. Access control around the frontend is therefore protecting much more than a visual monitoring screen.

Find every running Aspire Dashboard

Do not rely on a single repository search. The version declared in source control can differ from the image running in Kubernetes, an old Compose deployment, a CLI-selected binary, or an AppHost restored from a central package version.

Search repositories and deployment manifests

rg -n --hidden 
  'mcr.microsoft.com/aspire/dashboard|Aspire.(AppHost.Sdk|Hosting.AppHost|Dashboard.Sdk)' 
  --glob '!**/bin/**' --glob '!**/obj/**' .

Review Directory.Packages.props, project files, Compose files, Helm values, Kubernetes manifests, GitOps repositories, and CI/CD variables. A central package definition can override the version visible in an individual project.

Inspect resolved AppHost packages

dotnet list path/to/AppHost.csproj package --include-transitive 
  | grep -E 'Aspire.(Dashboard.Sdk|Hosting.AppHost|AppHost.Sdk)'

On PowerShell, replace grep with Select-String. Record the resolved Dashboard SDK package rather than only the top-level declaration.

Inspect running containers

docker ps --format '{{.ID}}t{{.Image}}t{{.Names}}' 
  | grep 'mcr.microsoft.com/aspire/dashboard'

docker inspect aspire-dashboard 
  --format '{{.Config.Image}} {{.Image}}'

The first value shows the configured image reference; the second is the local image ID. A mutable tag such as latest is not evidence that the running container is patched.

Inspect Kubernetes workloads

kubectl get deploy,statefulset,daemonset -A -o json 
  | jq -r '.items[] as $w
    | $w.spec.template.spec.containers[]
    | select(.image | contains("mcr.microsoft.com/aspire/dashboard"))
    | [$w.metadata.namespace, $w.kind, $w.metadata.name, .name, .image]
    | @tsv'

Also inspect completed Jobs, ephemeral environments, developer clusters, and generated manifests. Updating an AppHost package does not rewrite an already generated container-image reference.

Containment and evidence preservation

Microsoft’s advisory does not state that CVE-2026-118740 is being actively exploited, and no authoritative public indicator set was identified. Treat investigation as behavior-based rather than matching an invented URL or signature.

  1. Restrict the Dashboard frontend to trusted administration networks while patching.
  2. Preserve reverse-proxy, ingress, WAF, load-balancer, container, and Dashboard logs before retention rotates.
  3. Look for unauthenticated requests to unusual or nonexistent paths, especially followed by missing telemetry, unexpected UI activity, or token use.
  4. Compare telemetry retention and deletion patterns with normal operator activity and application deployment windows.
  5. If a standalone browser token may have been exposed, replace it and restart the patched Dashboard. Replace any statically configured value in the deployment secret.

A generated browser token is normally replaced when the Dashboard starts. A configured token must be changed deliberately. Review how the value is delivered to operators, because query strings can be retained in browser history, proxy logs, and support screenshots.

Patch each deployment type correctly

Standalone container

Pin the fixed stable image and recreate the container. Do not merely pull an image while leaving the old container running.

docker pull mcr.microsoft.com/aspire/dashboard:13.6.5
docker rm -f aspire-dashboard

docker run --detach 
  --name aspire-dashboard 
  --restart unless-stopped 
  -p 127.0.0.1:18888:18888 
  mcr.microsoft.com/aspire/dashboard:13.6.5

The minimal example binds the frontend to localhost and omits production telemetry configuration. Preserve your required volumes, certificates, authentication settings, API keys, resource limits, and network policy when rebuilding the real deployment.

AppHost using NuGet packages

Update the explicit Aspire.Hosting.AppHost or Aspire.AppHost.Sdk reference to 13.6.5 or later, then restore, rebuild, and restart. Verify the transitive platform-specific Dashboard SDK selected for the target runtime.

dotnet restore path/to/AppHost.csproj
dotnet list path/to/AppHost.csproj package --include-transitive 
  | grep 'Aspire.Dashboard.Sdk'
dotnet build path/to/AppHost.csproj --no-restore

If the AppHost selects a CLI-bundled Dashboard or a custom executable path, changing package references alone will not replace that binary. Update the selected bundle or path and restart the AppHost.

Hands-on lab: classify a synthetic Aspire inventory

This offline lab checks version evidence only. It does not contact a Dashboard, send telemetry, delete data, or reproduce the bypass.

Prerequisites

  • Python 3.9 or later.
  • An empty working directory.
  • No network access or elevated privileges.

1. Create the sample inventory

cat > aspire-inventory.json <<'JSON'
[
  {"name":"dev-observe","source":"container","version":"13.6.4"},
  {"name":"orders-apphost","source":"apphost-sdk","version":"13.6.5"},
  {"name":"legacy-apphost","source":"apphost-sdk","version":"13.6.3"},
  {"name":"shared-dashboard","source":"container","version":"latest"},
  {"name":"cli-dashboard","source":"cli-bundle","version":"unknown"},
  {"name":"custom-observe","source":"custom-path","version":"13.6.2"}
]
JSON

2. Run the classifier

#!/usr/bin/env python3
import json
import re

FIXED = (13, 6, 5)

def parse_version(value):
    match = re.fullmatch(r"(d+).(d+).(d+)", value)
    return tuple(map(int, match.groups())) if match else None

def classify(item):
    version = item["version"].strip().lower()
    if version in {"latest", "nightly", "edge"}:
        return "UNPINNED_VERIFY_DIGEST"
    parsed = parse_version(version)
    if parsed is None:
        return "UNKNOWN_RUNTIME_VERSION"
    return "PATCHED" if parsed >= FIXED else "VULNERABLE"

with open("aspire-inventory.json", encoding="utf-8") as handle:
    inventory = json.load(handle)

for item in inventory:
    print(f'{item["name"]:18} {item["source"]:12} {classify(item)}')

Save the script as classify-aspire.py, then run:

python3 classify-aspire.py

Expected output:

dev-observe        container    VULNERABLE
orders-apphost     apphost-sdk  PATCHED
legacy-apphost     apphost-sdk  VULNERABLE
shared-dashboard   container    UNPINNED_VERIFY_DIGEST
cli-dashboard      cli-bundle   UNKNOWN_RUNTIME_VERSION
custom-observe     custom-path  VULNERABLE

Troubleshooting and cleanup

  • If the script reports invalid JSON, check the commas and quotation marks in the inventory file.
  • Prerelease labels are intentionally classified as unknown. Verify the resolved build against Microsoft’s fixed release instead of guessing from the label.
  • A patched declaration with an old running container is still operationally vulnerable. Replace synthetic values with runtime evidence when adapting the logic.
rm -f aspire-inventory.json classify-aspire.py

Verify the fix without exploiting the flaw

For browser-token authentication, open a private browser session or send a header-only request to a deliberately nonexistent path. The fixed behavior should redirect the unauthenticated request to login and preserve a local return URL rather than initializing the Dashboard layout.

curl -k -I https://dashboard.example.invalid/route-that-does-not-exist

Expect an authentication redirect appropriate to the configured mode. Browser-token mode should redirect to the Dashboard login flow; OpenID Connect can redirect through the identity provider. Do not put a real browser token in the command line or a shared ticket.

Then verify the runtime version, confirm that authorized users can still view resources and telemetry, check that OTLP ingestion continues, and monitor logs for authentication errors. If telemetry was deleted before remediation, the upgrade will not reconstruct it; recover from retained exports or backups where available.

Hardening beyond version 13.6.5

  • Keep frontend authentication enabled. Use BrowserToken or OpenID Connect. Reserve anonymous mode for trusted local development.
  • Secure OTLP ingestion. Standalone mode can accept telemetry without authentication by default. Use API-key or client-certificate authentication when the endpoint crosses a trust boundary.
  • Restrict network reachability. Place the frontend and telemetry endpoints behind firewall, ingress, and identity controls appropriate to the environment.
  • Pin immutable deployment evidence. Record the image digest and resolved NuGet packages in the release artifact or SBOM.
  • Protect persisted data. Limit access to the Dashboard data directory because stored logs, traces, metrics, and resource properties can contain sensitive values.
  • Keep developer tooling in patch governance. Dashboards, CLIs, extensions, and generated manifests need owners and update rings just like production services. Our cargo-nextest security update guide shows a similar inventory-first workflow for developer tooling.

For another example of authorization controls failing at an application boundary, see our Prefab UI sandbox-escape response guide.

Conclusion

CVE-2026-118740 is easy to underestimate because the vulnerable input is a missing route, not a normal authenticated dashboard function. The practical impact is serious: unauthenticated telemetry deletion across deployment modes and possible browser-token exposure in standalone deployments.

Patch the component that actually runs. Pin the standalone image to 13.6.5 or later, update and rebuild AppHost packages, replace CLI-bundled or custom binaries, restart the service, rotate a potentially exposed browser token, and verify the unauthenticated NotFound path. Finish by hardening frontend, OTLP, network, and persisted-data controls so a future routing defect is not the only barrier protecting operational telemetry.

Official references

Similar Posts