EUVD-2026-98170
GHSA-cv7j-p3c2-ggx8
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain local access with low privileges
-
DeliverySupply crafted cfg_args config
-
ExploitVictim loads config into parser
-
Executionparse_cfg_args evaluates injected code
-
ImpactExecute code in user context
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Input neutralization, injection prevention
|
| Exploitation Conditions | Exploitation requires the attacker to control the cfg_args configuration argument processed by the parse_cfg_args function in internal/utils/common.py (the Sidecar Parsing component), and the victim/operator must load that attacker-influenced configuration - i.e. passive user interaction (UI:P) combined with existing local access and at least low privileges (PR:L). Limiting factors: there is no remote attack surface (local environment only), the attacker cannot act fully unattended because the config must be loaded by a user, and impact is confined to the local user's context with only Low confidentiality/integrity/availability effect. This is a code-injection flaw gated by who can supply and load configuration input, not a default-configuration remote exposure. |
| Impact | This is a low-priority, low-real-risk issue despite being a code injection (CWE-74) flaw. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:L/UI:P) and the 2.4 base score consistently point to a minor, locally-exploitable weakness: the attacker must already have local access, hold at least low privileges (PR:L), and rely on passive user interaction (UI:P), while the impact is only Low across confidentiality, integrity and availability (VC:L/VI:L/VA:L) with no scope change. All three high-risk amplifiers are absent: there is no CISA KEV listing, no public POC referenced, and no EPSS score supplied in the input. The signals do not conflict - CVSS local vector, the description ('attack can only be performed from a local environment'), and the code-injection-via-config-argument mechanism all agree this is a local, self-/operator-triggered issue rather than a remotely weaponizable one. The main caveat is process maturity, not exploitability: the description states the project was notified via an issue report but has not responded, so no vendor-confirmed patch exists. Net assessment: a genuine but minor code-injection bug in a niche research tool, appropriate for routine patching, not emergency response. |
| Exploit ScenarioDerived | A user is induced to load an attacker-supplied configuration (cfg_args) into CityGaussian; when parse_cfg_args in internal/utils/common.py processes the crafted argument, it injects and executes attacker-controlled code in the local user's context. No public exploit code was identified at time of analysis, and the attack requires local access plus the victim loading the malicious config. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
Code injection in Linketic CityGaussian through version 2.0 allows a local, low-privileged attacker who can influence the cfg_args value processed by parse_cfg_args in internal/utils/common.py to execute code in a victim's context once that operator loads the tampered configuration. There is no remote attack surface and no public exploit code identified at time of analysis, and the maintainers have not responded to the reported issue (#206), so no vendor patch is available; our assessment rates this as a low-priority, low-real-risk flaw because exploitation requires local access plus passive user interaction and is confined to low confidentiality, integrity, and availability impact.
RemediationAI
No vendor-released patch was identified at time of analysis: the project was notified via issue https://github.com/Linketic/CityGaussian/issues/206 and has not responded, and no fixed version is named in the VulDB entries (https://vuldb.com/cve/CVE-2026-108941, https://vuldb.com/vuln/416766). Until an upstream fix ships, treat cfg_args as untrusted input: replace or wrap the eval-style handling in parse_cfg_args with a strict parser (e.g., ast.literal_eval or an allow-list of expected keys and value types) so injected expressions cannot execute - the trade-off is that unusual but legitimate configuration syntax may be rejected, which should be validated against your workflows. Restrict filesystem write access to configuration and sidecar files so only trusted administrators can modify them (chmod/chown and shared-directory hygiene), accepting that this may break multi-user or shared-config setups; never load configuration files from untrusted or world-writable locations. Run CityGaussian in a container or sandbox with minimal privileges and no access to sensitive host data or credentials to contain any successful execution, at the cost of some performance and integration overhead. Monitor the GitHub repository and issue #206 for a released patched version, and apply it as soon as it becomes available.
Affected VersionsENISA
Affected Packages
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
The flaw is a CWE-74 injection (improper neutralization of special elements) in the Sidecar Parsing component of CityGaussian, a 3D Gaussian splatting / radiance-field reconstruction toolkit. The parse_cfg_args function in internal/utils/common.py takes the cfg_args configuration argument and processes it in a way that allows injected content to be evaluated as code rather than treated as inert data - the classic pattern where configuration strings are passed to an eval/exec-like interpreter instead of a safe parser such as ast.literal_eval or a strict argument whitelist. Because configuration and sidecar files are read from the local filesystem, the attack path is local: the adversary must already have the ability to write or modify the configuration consumed by CityGaussian, and the operator must then load it. No CPE identifiers were supplied in the source data, but the affected artifact is the upstream Linketic/CityGaussian repository at versions up to and including 2.0, and the reported issue is tracked at https://github.com/Linketic/CityGaussian/issues/206.
Know when the next one hits your stack
- 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
CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:P/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N
Local-only attack (AV:L) requiring a low-privileged local user to supply config and a victim to load it (PR:L, UI:R); limited code execution yields Low C/I/A with no scope change.
Primary rating from Vendor (vuldb).
CVSS VectorVendor: vuldb
DescriptionCVE.org
A vulnerability was identified in Linketic CityGaussian up to 2.0. This affects the function parse_cfg_args of the file internal/utils/common.py of the component Sidecar Parsing. The manipulation of the argument cfg_args leads to code injection. The attack can only be performed from a local environment. The project was informed of the problem early through an issue report but has not responded yet.
Threat Intelligence Overview
NVD
CVE.org
EPSS
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Exploit-DB