Skip to main content

gopls CVE-2026-42503

| EUVDEUVD-2026-27872 HIGH
Binding to an Unrestricted IP Address (CWE-1327)
2026-05-06 Go GHSA-9344-f92h-vr44
8.8
CVSS 3.1 · Vendor: Go
View

Attack ChainAIDerived

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

  1. Access
    Scan adjacent network for open ports
  2. Delivery
    Identify gopls LSP endpoint
  3. Exploit
    Send malicious LSP execute command
  4. Execution
    Achieve code execution as developer
  5. Impact
    Access source code and credentials

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Hardware binding mechanism
Exploitation Conditions

Exploitation requires the developer to manually invoke gopls with specific non-default debugging flags: either -listen flag with a value lacking explicit host specification (e.g., -listen=:8080 instead of -listen=127.0.0.1:8080) or -port flag in any usage. The developer and attacker must be on the same adjacent network segment (AV:A) such as shared WiFi, corporate LAN, or cloud VPC. Normal gopls operation using default pipe-based IPC is not vulnerable - only network-enabled debugging configurations expose the attack surface. Limiting factors: not exploitable against default gopls installations, requires developer to be using debugging features, and attack surface exists only while gopls process is running with network flags enabled. Adjacent network requirement prevents internet-wide exploitation but does not protect against attacks from compromised systems on the same network segment or malicious insiders.

Impact

CVSS 8.8 (High) reflects unauthenticated remote code execution but the Adjacent Network (AV:A) vector significantly constrains real-world exploitability compared to internet-reachable vulnerabilities. Attack complexity is Low (AC:L) with no privileges required (PR:N) and no user interaction (UI:N), meaning exploitation is trivial once the preconditions are met. However, the exploitation conditions are highly specific: developers must manually invoke gopls with debugging flags in non-default configurations, AND be on a shared untrusted network. This is not a default-configuration vulnerability affecting production systems but rather a developer tooling misconfiguration risk. The high confidentiality, integrity, and availability impact (C:H/I:H/A:H) reflects that successful exploitation grants arbitrary code execution with the privileges of the developer's IDE process, potentially accessing source code, credentials, and development infrastructure. No CISA KEV listing indicates this is not being actively exploited at scale despite the straightforward attack vector. Real-world priority is Medium for organizations with developers working from untrusted networks (remote work, conferences, co-working spaces) but Low for isolated development environments. CRITICAL GAP: EPSS score not available, POC status uncertain from provided references - fix availability confirmed via Go change list CL/774381 but exact patched version not specified in available data.

Exploit ScenarioDerived

A developer working from a coffee shop runs gopls with 'gopls -listen=:8080' to debug IDE integration issues, inadvertently binding to 0.0.0.0. An attacker on the same WiFi network scans for open ports, discovers port 8080 running gopls, and sends Language Server Protocol (LSP) requests to execute arbitrary Go code through gopls's code execution capabilities. The attacker gains code execution with the developer's privileges, accessing source code repositories, API keys in environment variables, and potentially pivoting to connected development infrastructure.

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

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

Alert me

AnalysisAIv1 – May 06, 2026

Adjacent network code execution in gopls language server occurs when developers use debugging flags -listen or -port without explicit host specification. The Go language server (gopls) binds to all network interfaces (0.0.0.0) instead of localhost when these debugging flags are used, enabling unauthenticated remote code execution from adjacent network attackers. No public exploit identified at time of analysis, though the attack vector is straightforward for developers who enable network debugging in shared network environments like coffee shops or corporate LANs. EPSS data not available for this recent CVE.

RemediationAI

Update gopls to the version containing the fix from Go change list 774381 (exact version number to be confirmed from https://go.dev/cl/774381 when release is tagged). Until patched version is deployed, developers using gopls debugging flags must explicitly specify localhost binding: use '-listen=127.0.0.1:8080' or '-listen=localhost:8080' instead of ':8080' to prevent binding to all network interfaces. Workaround trade-off: explicit localhost binding eliminates network exposure but requires modifying existing debugging workflows and launch configurations. Network-layer mitigation: configure host-based firewalls to block inbound connections to gopls debugging ports (typically high-numbered ports) from non-localhost sources, though this requires identifying which ports developers are using and does not prevent attacks from other processes on the same machine. Organizations should audit developer documentation and IDE configuration templates to replace any examples showing unsafe flag usage patterns. For developers who must use network-accessible gopls instances (remote debugging scenarios), implement authentication proxy or SSH tunneling rather than direct network exposure.

Affected VersionsENISA

golang.org/x/tools/gopls 0.0.0 <0.22.0

Affected Packages

euvd golang_org_x_tools_gopls fix: 0.22.0

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

gopls is the official Go language server providing IDE features like code completion and diagnostics. It typically uses inter-process communication via named pipes for local-only communication between the editor and language server process. The -listen and -port flags are debugging features allowing network-based communication with the language server. CWE-1327 (Binding to an Unrestricted IP Address) occurs when the code fails to validate that network binding uses localhost (127.0.0.1) versus all interfaces (0.0.0.0). When users specify values like ':8080' (missing host component) or use -port without additional host specification, Go's default network binding behavior accepts connections from any network interface. The golang.org/x/tools/gopls package is affected across all versions until patched, as indicated by the CPE string with wildcard version.

Know when Golang Org X Tools Gopls 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 (Go) PRIMARY 8.8 HIGH
AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
SUSE HIGH
Red Hat 8.8 HIGH

Primary rating from Vendor (Go).

CVSS VectorVendor: Go

Attack Vector
Adjacent
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
May 06, 2026 - 18:02 EUVD
CVSS changed
May 06, 2026 - 17:22 NVD
8.8 (HIGH)

DescriptionCVE.org

gopls by default communicates via pipe. However, -port and -listen flags are supported as means of debugging. If -listen is given a value without an explicit host (e.g. :8080), or -port is used, gopls will listen on 0.0.0.0. As a result, users might inadvertently cause gopls to bind 0.0.0.0. This can allow a malicious party on the same network to execute code arbitrarily via gopls.

Executive ViewAI

Why It Matters

CVE-2026-42503 affects the Go language server (gopls) and enables unauthenticated remote code execution when developers enable debugging flags (-listen or -port) without specifying localhost. Any organization where developers use gopls in shared network environments (corporate networks, remote offices, public WiFi) faces risk of arbitrary code execution on affected developer workstations, potentially compromising source code, credentials, and internal systems.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) Immediately disable -listen and -port debugging flags in all gopls configurations; (2) Restrict gopls to localhost binding via firewall rules or IDE configuration enforcement; (3) Prohibit gopls usage on shared/untrusted networks until patch availability; (4) Isolate developer workstations on segmented VLANs with egress filtering to prevent lateral movement if compromised; (5) Monitor network traffic for unexpected gopls listening ports (default 37374) on 0.0.0.0 interface.

Threat Intelligence Overview

EPSS Score
0.0%
Top 96% exploitable
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor VulDB

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.0%
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
Controlled
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Vendor StatusVendor

SUSE

Severity: Important

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