Skip to main content

Skyhook Radar CVE-2026-82026

| EUVDEUVD-2026-101018 HIGH
Missing Authorization (CWE-862)
2026-10-14 VulnCheck GHSA-fp33-g9vp-3ffr
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach /api/local-terminal WebSocket
  2. Exploit
    Bypass runtime-mode check (no RBAC)
  3. Execution
    Spawn privileged /bin/bash -l shell
  4. Impact
    Execute code with Radar kubeconfig and credentials

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization checks on every request
MITRE ATT&CK

1 technique across 1 tactic: Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires network reachability to the Radar host's /api/local-terminal WebSocket endpoint while Radar is running; no RBAC/role check is enforced, and the description indicates it succeeds even when the --disable-local-terminal flag is set, because the code trusts only a runtime-mode check. The principal LIMITING factors are deployment-driven: Radar is a local-first developer tool (kubectl-radar / desktop app) that is typically run on an individual workstation and likely binds the endpoint to localhost, so exploitation generally requires the attacker to already have local/same-host access or for the operator to have deliberately exposed the port to the network. No user interaction is needed, and per the description authentication is not reliably required despite the vendor's PR:L marking.

Impact

This is a CWE-862 missing-authorization flaw that yields full remote code execution on the Radar host, so the technical impact is severe (vendor CVSS 4.0 8.7 with VC:H/VI:H/VA:H). The vendor vector states AV:N/AC:L/PR:L/UI:N, indicating a low-complexity network attack requiring only low privileges. However, there is a notable internal conflict: the description explicitly says 'authenticated OR unauthenticated attackers' can exploit it because the endpoint relies only on a runtime-mode check instead of role-based access control, which argues for PR:N (truly unauthenticated) rather than the vendor's PR:L - verify authentication requirements with the vendor/VulnCheck advisory. No EPSS score, SSVC decision, or KEV status was provided in the input, and no public exploit is referenced, so exploitation probability cannot be quantified from the data. Mitigating the raw severity is the product's nature: Radar is a local-first, no-account Kubernetes visibility tool typically run on a developer workstation, so the /api/local-terminal WebSocket is likely bound to localhost unless deliberately exposed - meaning real-world network reach may be far narrower than AV:N suggests. Net assessment: high technical severity and trivially exploitable once reachable, but likely limited blast radius due to niche deployment and probable loopback binding; prioritize patching for any environment where Radar is network-exposed.

Exploit ScenarioDerived

An attacker who can reach the Radar host's /api/local-terminal WebSocket endpoint connects to it and, because the endpoint enforces only a runtime-mode check rather than RBAC, is granted an interactive privileged shell. The shell runs /bin/bash -l with Radar's own kubeconfig and process credentials injected, giving the attacker code execution as Radar and a pivot into the Kubernetes cluster - and this works even when the --disable-local-terminal flag is set. No public exploit code is referenced in the provided data.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.9% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 14, 2026

Missing authorization in the handleLocalTerminal WebSocket handler of Skyhook Radar before 1.12.2 lets an attacker who can reach the /api/local-terminal endpoint spawn an interactive /bin/bash -l shell on the Radar host with Radar's own kubeconfig and process credentials injected into the environment, achieving remote code execution with Radar's privileges. The handler is governed only by a runtime-mode check instead of role-based access control, and per the advisory the exploit still works when the operator has set --disable-local-terminal, so that flag cannot be relied on as a mitigation in vulnerable builds. The vendor's CVSS 4.0 rating is 8.7 (VC:H/VI:H/VA:H, PR:L) while our independent reassessment scores it CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, meaning authentication is not reliably enforced despite the PR:L marking; there is no CISA KEV entry and no public exploit code identified at time of analysis, and real-world exposure is chiefly limited by the fact that Radar is a local-first developer tool that is normally bound to localhost on an individual workstation.

RemediationAI

Upgrade to Radar v1.12.2 or later, which is the vendor-released patch and the first version containing the authorization fix for the local-terminal WebSocket endpoint; fixed artifacts for kubectl-radar (Homebrew, Scoop, PowerShell installer, and manual tarballs) and Radar Desktop (.deb, .rpm, Homebrew cask, and Windows installer) are published at https://github.com/skyhook-io/radar/releases/tag/v1.12.2 and the underlying changes are in https://github.com/skyhook-io/radar/pull/1534 and https://github.com/skyhook-io/radar/pull/1537. Until every instance is upgraded, treat network exposure as the primary compensating control: bind Radar's HTTP/WebSocket listener to loopback only and never publish the port to a LAN, VPN, or container network, since exploitation requires reachability to /api/local-terminal; if binding cannot be restricted, block inbound TCP to the Radar port with a host firewall or Kubernetes network policy, accepting that this breaks legitimate remote access from the desktop app to a CLI instance on another host. Do not rely on the --disable-local-terminal flag as a mitigation, because the advisory states the endpoint can still be reached and abused when that flag is set in vulnerable versions. As a secondary containment measure, run Radar with a deliberately scoped kubeconfig or service account holding only the permissions the operator needs, since the injected shell inherits Radar's credentials and least-privilege kubeconfig directly bounds the blast radius of a successful exploit; the trade-off is reduced functionality for cluster-wide browsing and Helm management. Restricting local/same-host access to trusted users is also advisable because the endpoint can be reached by any process on the host when it is bound to localhost, though this offers no protection once the port is network-exposed. No vendor-released patch was identified as unavailable; the upgrade path above is complete, and no public exploit code or CISA KEV entry was identified at time of analysis.

Affected VersionsENISA

Radar 0 <1.12.2

Affected Packages

euvd radar fix: 1.12.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Radar is an open-source, local-first Kubernetes visibility tool shipped as the kubectl-radar CLI plugin (a Go binary) and a desktop application for macOS, Linux, and Windows. The vulnerability is a CWE-862 Missing Authorization defect in the handleLocalTerminal handler that backs the /api/local-terminal WebSocket route: the code checks only the process runtime mode (a feature-availability style check) and never performs a role- or identity-based authorization decision before upgrading the connection and launching a login shell. Because the spawned shell is a login shell run as the Radar process, it inherits Radar's environment, including its kubeconfig context and cluster credentials, so the attacker effectively inherits every Kubernetes permission Radar holds in addition to host-level code execution. The design flaw is that a runtime-mode toggle is used as a security boundary: the --disable-local-terminal flag is checked in a path that the WebSocket handler bypasses, which is why the documented hardening switch does not stop exploitation. The CPE cpe:2.3:a:skyhook-io:radar:*:*:*:*:*:*:*:* uses a wildcard version, reflecting that the CPE dictionary does not encode the fixed version; version 1.12.2 is the first release containing the authorization fix. The WebSocket protocol matters here because an unauthenticated or low-privileged client can complete the HTTP upgrade and then drive the terminal session interactively, making this a straightforward RCE primitive rather than a data-disclosure bug.

Know when Radar gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (VulnCheck) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 9.8 CRITICAL

Missing authorization (CWE-862) lets attackers reach the endpoint without valid credentials, so PR:N over the vendor's PR:L; a privileged shell on the host yields full C/I/A:H.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Radar before 1.12.2 contains a missing authorization vulnerability in the handleLocalTerminal WebSocket endpoint (/api/local-terminal) that allows authenticated or unauthenticated attackers to spawn a privileged shell by relying only on a runtime-mode check instead of role-based access control. Attackers can connect to the endpoint to execute /bin/bash -l on the Radar host with Radar's own kubeconfig and process credentials injected into the shell environment, achieving remote code execution with Radar's privileges even when the --disable-local-terminal flag is set.

Executive ViewAI

Why It Matters

Skyhook Radar, a Kubernetes management component, contains an authorization flaw that lets anyone who can reach the service run commands on the Radar host using Radar's own cluster credentials, effectively granting an intruder the same access Radar holds across managed clusters. Because the flaw can be triggered without valid credentials and the documented --disable-local-terminal flag does not prevent it in vulnerable builds, configuration hardening alone cannot close the exposure; only upgrading to 1.12.2 or later does. Platform engineering and security leadership should treat this as a priority remediation item, as a successful compromise could expose cluster credentials and enable lateral movement into production Kubernetes environments.

Business Impact: High
Compensating Controls

Apply vendor patch. Until patched, restrict network reachability to the /api/local-terminal endpoint; note that the --disable-local-terminal flag does not mitigate the flaw in vulnerable builds.

Threat Intelligence Overview

EPSS Score
0.9%
Top 40% exploitable
Prevalence
Low
niche open-source local-first Kubernetes visibility tool, limited enterprise footprint
Data Quality
7 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.9%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

45
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy