Skip to main content

CodeChecker CVE-2025-40843

HIGH
Stack-based Buffer Overflow (CWE-121)
2025-10-28 85b1779b-6ecd-4f52-bcc5-73eac4659dcf
7.8
CVSS 3.1 · NVD
View

Attack ChainAIDerived

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

  1. Access
    Gain low-priv local access to build host
  2. Delivery
    Influence CodeChecker log input/env
  3. Exploit
    Supply overlong path to ldlogger strcpy
  4. Execution
    Overflow 4096-byte stack buffer
  5. Impact
    Execute code in tool's context

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Stack buffer bounds checking
MITRE ATT&CK

1 technique across 1 tactic: Execution

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

Exploitation Conditions

Exploitation requires local ability to execute the 'CodeChecker log' command with attacker-controlled input - specifically a crafted overlong compilation path/argument that is copied via unchecked strcpy() into a fixed 4096-byte stack buffer in the internal ldlogger library; the public PoC also sets the CC_LOGGER_DEF_DIRS=1 environment variable. The key limiting factor is that only environments where 'CodeChecker log' processes untrusted or externally-influenced input (e.g., shared CI runners or automated build pipelines ingesting user-supplied paths) are realistically at risk; the local attack vector (AV:L) and required low-privilege execution (PR:L) mean a purely isolated developer workstation running trusted builds faces minimal exposure. Affected versions are CodeChecker through 6.26.1; fixed in 6.26.2.

Impact

This is a moderate-priority, high-CVSS-but-low-real-world-urgency issue when judged across all signals. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) describes a locally-exploitable stack buffer overflow (CWE-121) requiring low privileges and no user interaction, with full confidentiality/integrity/availability impact consistent with arbitrary code execution in the context of the user running the tool. The EPSS score is very low (0.19%, 8th percentile), indicating no meaningful signal of broad opportunistic exploitation, and the CVE is NOT on CISA KEV, so there is no evidence of active exploitation. A proof-of-concept is publicly available (the GHSA advisory includes a working bash PoC), so publicly available exploit code exists - but this is distinct from active exploitation and does not change the local-only attack surface. No SSVC decision data was provided in the input. The signals are internally consistent: the local attack vector (AV:L) plus low EPSS plus absence from KEV all point to a developer-tooling flaw that is only dangerous where the vulnerable 'CodeChecker log' command processes attacker-influenced input, rather than a remotely-exploitable, mass-targeted vulnerability. Real priority is driven by context: environments that pipe untrusted/user-controlled paths or build commands into 'CodeChecker log' (e.g., shared CI runners) should patch promptly; isolated developer workstations face limited realistic risk.

Exploit ScenarioDerived

In a shared CI/build environment, an attacker who can influence the arguments or environment passed to the 'CodeChecker log' command supplies a crafted overlong file path (the public PoC uses ~4090 'A' characters with CC_LOGGER_DEF_DIRS=1) that overruns a fixed 4096-byte stack buffer via an unchecked strcpy() in the internal ldlogger library. Because this requires local execution with low privileges (AV:L/PR:L) and no user interaction, exploitation yields code execution in the context of the process running the log command. A working proof-of-concept is publicly available in the GHSA advisory.

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

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

Alert me

AnalysisAIv1 – Oct 08, 2026

Stack-based buffer overflow in CodeChecker through 6.26.1 can be triggered by the local CodeChecker log command when it processes a crafted overlong compilation path, allowing a low-privileged local attacker to corrupt memory and potentially execute code or crash the process. A publicly available exploit code exists, but EPSS is only 0.19% (8th percentile), and this is a moderate-priority, high-CVSS-but-low-real-world-urgency issue when judged across all signals. The vulnerability requires local invocation of CodeChecker log with attacker-influenced input, so shared CI runners or automated build pipelines ingesting untrusted paths are the realistic risk scenarios; fixed in CodeChecker 6.26.2.

RemediationAI

Upgrade to CodeChecker 6.26.2 or later (vendor-released patch: 6.26.2; upstream fix commit 4122eb1b43d00c880e4f0747d2ca0a674feb7a50). If immediate upgrade is not possible, treat all input to CodeChecker log as untrusted: avoid running the command on attacker-influenced compilation paths, restrict invocation to trusted users and CI jobs, sanitize or cap path lengths in build wrappers, and consider not enabling CC_LOGGER_DEF_DIRS unless required. These compensating controls reduce exposure but do not eliminate the underlying buffer overflow. See the advisory at https://github.com/Ericsson/codechecker/security/advisories/GHSA-5xf2-f6ch-6p8r.

Affected Packages

pypi codechecker fix: 6.26.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

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

Technical ContextAI · show details

The internal ldlogger library, executed by the CodeChecker log command, copies a command-line path or argument into a stack-allocated buffer with a fixed size of 4096 bytes using strcpy() without length checks (CWE-121, stack-based buffer overflow). The public proof of concept sets CC_LOGGER_DEF_DIRS=1 and supplies roughly 4090 'A' characters in a compilation path to overrun the buffer. CPE data identifies Ericsson CodeChecker (cpe:2.3:a:ericsson:codechecker:*:*:*:*:*:*:*:*) as the affected product, with all versions through 6.26.1 vulnerable and version 6.26.2 containing the fix. The upstream commit 4122eb1b43d00c880e4f0747d2ca0a674feb7a50 and GHSA-5xf2-f6ch-6p8r document the issue.

Know when Codechecker 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

NVD PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.8 HIGH

Flaw is triggered only by locally invoking 'CodeChecker log' as a low-privileged user (AV:L, PR:L), reliably overflowing a fixed stack buffer (AC:L) for code execution with full C/I/A impact.

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

Primary rating from NVD.

CVSS VectorNVD

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

DescriptionNVD

CodeChecker is an analyzer tooling, defect database and viewer extension for the Clang Static Analyzer and Clang Tidy.

CodeChecker versions up to 6.26.1 contain a buffer overflow vulnerability in the internal ldlogger library, which is executed by the CodeChecker log command.

This issue affects CodeChecker: through 6.26.1.

Executive ViewAI

Why It Matters

CodeChecker, the open-source static analysis tool embedded in many developer build and CI pipelines, contains a high-severity stack buffer overflow (CVE-2025-40843) that can be triggered when its log command processes a maliciously overlong compilation path. The realistic exposure sits in shared CI runners and automated build systems that ingest path input from untrusted or external sources, where a successful trigger could crash build jobs or execute attacker-controlled code inside the build environment itself. Leadership should care because those environments commonly hold source code, build credentials, and deployment rights, so a single compromised pipeline can extend well beyond one developer workstation - though currently low real-world exploitation activity (EPSS 0.2%) makes this a prioritized hardening item rather than an emergency.

Business Impact: Medium
Compensating Controls

Patch/upgrade status is inconsistent in the available data: structured metadata lists no vendor patch, while the advisory description states the flaw is fixed in CodeChecker 6.26.2 - treat 6.26.2 as the remediation target and confirm with the vendor. Until upgraded, restrict CodeChecker log to trusted, internally generated paths; reject or sanitize overlong and externally supplied compilation paths; execute CodeChecker in non-privileged, ephemeral CI containers with no access to production secrets; apply least-privilege build credentials; and monitor build runners for process crashes or unexpected child processes.

Threat Intelligence Overview

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Low
Niche open-source static-analysis developer/CI tool, limited production footprint
Exploit
POC
Public exploit code exists
Data Quality
4 sources
Confidence: Medium

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 Yes
EPSS 0.2%
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· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

A stack-based buffer overflow occurs when a program writes more data to a buffer located on the stack than it was allocated to hold.

Affected Products (CPE)NVD

cpe:2.3:a:ericsson:codechecker:*:*:*:*:*:*:*:*

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