CVE-2026-13501: ANTLR4 GoTarget Command Injection Vulnerability

Technical summary

The vulnerability resides in the GoTarget.java component of ANTLR4's code generation toolchain. The flaw is a classic command injection issue (CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component, and CWE-77: Improper Neutralization of Special Elements used in a Command). When ANTLR4 generates Go source code, it invokes gofmt to format the output. The GoTarget implementation fails to properly sanitize or escape user-controlled input before passing it to the system command handler, allowing an attacker to inject shell metacharacters or additional commands. The attack surface is local; an attacker must have the ability to execute ANTLR4 or influence its input files on the target system.

Business impact

For development teams using ANTLR4 to generate parsers and code generators, this vulnerability introduces a supply-chain risk. If an attacker can influence grammar files or input to the build process, they can gain code execution during the build phase. This is particularly concerning in CI/CD pipelines where ANTLR4 may be invoked automatically. The impact extends beyond individual developers to any downstream consumers of generated code if the build environment is compromised. Organizations shipping products built with affected ANTLR4 versions should assess whether their build infrastructure was exposed.

Affected systems

ANTLR4 versions up to 4.13.2 are affected. The vulnerability is triggered specifically when using the Go code generation target (GoTarget). Organizations should inventory their use of ANTLR4—both as a direct dependency and as a transitive dependency in build tools or language frameworks. Go-based projects and polyglot development teams that rely on ANTLR4 for parser generation are most directly impacted.

Exploitability

The vulnerability is exploitable only from a local context (AV:L in the CVSS vector), meaning an attacker needs local system access or the ability to influence input files on the affected system. However, the exploit has been publicly disclosed, reducing the bar for attackers familiar with ANTLR4's architecture. The attack requires no elevated privileges (PR:L indicates low privilege is sufficient) and no user interaction. In cloud-native and containerized build environments, local access is more easily achieved through compromised CI/CD agents, malicious container images, or shared build servers.

Remediation

Upgrade ANTLR4 to a version released after 4.13.2 that includes the fix for the GoTarget command injection vulnerability. Verify the patched version against the vendor's official release notes. Immediately review your build pipeline configuration to ensure ANTLR4 invocations are isolated and that input files come from trusted sources. For projects unable to upgrade immediately, restrict execution of ANTLR4 to isolated build environments with minimal network access and implement input validation on grammar files before processing.

Patch guidance

Check the ANTLR4 project repository and release pages for versions newer than 4.13.2. Patch deployment should be prioritized for any build automation systems that automatically invoke ANTLR4, as these represent high-risk attack vectors. Verify that your organization's version of ANTLR4 is explicitly referenced and up-to-date in your build manifests (pom.xml, gradle files, go.mod, package.json, or equivalent). Test the patched version in a staging environment with your existing grammar definitions to ensure code generation output remains correct.

Detection guidance

Monitor system call logs and process execution records for ANTLR4 invocations that generate unexpected child processes or shell commands. Watch for unusual command-line arguments passed to gofmt or similar formatting tools. In CI/CD logs, flag ANTLR4 execution with non-standard input files or grammar sources outside your version control repository. Conduct static analysis of your grammar files for suspicious syntax or injection patterns that might be interpreted as commands. Review build logs for error messages or warnings from gofmt that might indicate command injection attempts.

Why prioritize this

Although the CVSS base score of 5.3 (Medium) reflects the local-only attack surface, the vulnerability's presence in the build pipeline makes it operationally significant. Public disclosure and vendor non-responsiveness remove any uncertainty about exploitability. Organizations should prioritize patching ANTLR4 to reduce supply-chain risk, especially in CI/CD and automated build environments where local compromise can cascade to all downstream artifacts.

Risk score, explained

The CVSS 3.1 score of 5.3 accounts for local attack vector (AV:L), low complexity (AC:L), low privilege requirement (PR:L), no user interaction (UI:N), unchanged scope (S:U), and confidentiality, integrity, and availability impacts (C:L, I:L, A:L). While a Medium severity baseline is appropriate given the local-only constraint, context matters: in shared or automated build environments, the practical risk is higher. The public disclosure and lack of vendor response increase real-world exploit likelihood.

Frequently asked questions