Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as workspace member
-
DeliveryAuthor malicious function-library code
-
ExploitRegister MetaPathFinder invoking ctypes.CDLL
-
ExecutionBypass dlopen heuristic and resolve real syscall via dlsym RTLD_NEXT
-
PersistExecute blocked syscalls as sandbox user
-
ImpactRead/write files, run processes, access network
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V15 - Secure Coding and Architecture Protection mechanism completeness
|
| Exploitation Conditions | Requires an authenticated MaxKB workspace member who can create and execute function-library (tool) code that runs inside the LD_PRELOAD syscall sandbox - this code-authoring capability is the primary prerequisite and gate. The target must be running MaxKB prior to 2.10.6-lts with the LD_PRELOAD sandbox enforcing a syscall blacklist (the default protection being bypassed). Exploitation depends on the sandbox's dlopen protection using the removed backtrace call-stack heuristic (called_from_python_import) and on _ctypes remaining loadable by the sandbox user; the fix both replaces the heuristic and, when dlopen is disallowed, strips the sandbox user's read permission on the ctypes shared object. Escaped capabilities are limited to whatever the low-privilege sandbox OS user can access (files, processes, network), not root, which bounds real-world impact. |
| Impact | This is a sandbox-escape / protection-mechanism failure (CWE-693) in MaxKB's LD_PRELOAD-based syscall sandbox, not a conventional remote code-execution flaw. The vendor CVSS of 6.3 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L) is driven down by the low per-impact ratings and the PR:L authentication requirement. However, that scoring understates the outcome: the entire purpose of the exploit is to defeat the syscall blacklist and regain arbitrary file read/write, process execution, and network access - capabilities the sandbox exists to prevent - hence my independent assessment raises the impact metrics. AV:N is technically correct because the attacker interacts over the network as an authenticated workspace member, but exploitation is really a code-authoring/config-adjacent action (writing function-library code that runs in the sandbox), so PR:L is essential and PR:N would be wrong. No EPSS score, KEV listing, or POC is present in the input, so there is no signal of active or automated exploitation - this is a real but pre-exploitation issue whose realistic priority is bounded by (a) needing an authenticated workspace member who can author/run function-library code and (b) the escaped capabilities being confined to the low-privilege sandbox OS user. It is a genuine security-boundary break worth patching, but not a mass-exploitation, high-urgency emergency absent evidence of exploitation. Note the impact-severity disagreement between vendor (C:L/I:L/A:L) and this analysis (see assessed vector) - verify against the vendor advisory GHSA-6h35-c779-4v37. |
| Exploit ScenarioDerived | An authenticated MaxKB workspace member authors function-library (tool) code that runs inside the LD_PRELOAD sandbox. The code registers an importlib.abc.MetaPathFinder whose callback invokes ctypes.CDLL, so the sandbox's dlopen call-stack heuristic sees a legitimate-looking Python import frame; it then uses unhooked dlsym with RTLD_NEXT to resolve glibc's real syscall entry point, bypassing the syscall blacklist to read/write files, spawn processes, and reach the network as the sandbox user. No public exploit identified at time of analysis, though the fix commit and advisory disclose the technique in enough detail to reconstruct it. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 21, 2026
MaxKB releases prior to 2.10.6-lts allow an authenticated workspace member who can author and run function-library (tool) code to escape the built-in LD_PRELOAD syscall sandbox and act with the sandbox OS user's privileges, reading or writing files, spawning processes, and reaching networks that the sandbox was meant to block. The escape works because the sandbox's dlopen guard relied on a call-stack heuristic that can be satisfied from an importlib.abc.MetaPathFinder callback while loading ctypes, after which the real glibc syscall can be resolved with dlsym/RTLD_NEXT and invoked outside the interception layer. This is a protection-mechanism failure (CWE-693) rather than conventional unauthenticated RCE; the vendor-published score is 6.3, but the assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H because once the sandbox is defeated the escaped user's file, process, and network access is fully available. No public exploit was identified at time of analysis, and the issue is fixed in 2.10.6-lts.
RemediationAI
Vendor-released patch: upgrade to MaxKB 2.10.6-lts (https://github.com/1Panel-dev/MaxKB/releases/tag/v2.10.6-lts), which incorporates commit d4bd22af8ba14a9dea317f9034332fec4e964697; per the advisory GHSA-6h35-c779-4v37 this is the only fully supported fix, since the change replaces the bypassable backtrace/call-stack dlopen heuristic and revokes the sandbox user's read permission on the _ctypes shared object whenever dlopen is disallowed. If upgrading immediately is not possible, apply the fix's own compensating logic manually: identify the _ctypes extension loaded by the interpreter that runs sandboxed tool code (python -c "import _ctypes; print(_ctypes.__file__)") and chmod it to remove group/other/owner read as appropriate for the sandbox account (e.g. clear the 0o040 bit on the sandbox user), accepting that any legitimate function-library code depending on ctypes will fail and that a Python/package upgrade may restore the permissions. Because the sandbox is a user-space LD_PRELOAD interposer that an escaped process can always slip past, the durable secondary control is kernel-level confinement of the sandbox account - a seccomp-bpf filter denying the syscall classes the blacklist intended to block, plus AppArmor/SELinux or namespace isolation for file, process, and network access - at the cost of policy engineering and possible breakage of legitimate tool workflows. In parallel, reduce the attack surface by restricting who may author or execute function-library code (trim workspace membership and the code-authoring role), and verify the sandbox account owns no sensitive mounts or credentials and has tightly scoped egress, since the realistic blast radius is bounded by that low-privilege user's reachable files, processes, and network rather than root. Do not treat enabling the sandbox's allow_dl_open option as a fix; it removes the restriction entirely. References: https://github.com/1Panel-dev/MaxKB/security/advisories/GHSA-6h35-c779-4v37 and https://github.com/1Panel-dev/MaxKB/commit/d4bd22af8ba14a9dea317f9034332fec4e964697.
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
MaxKB confines user-supplied function-library code with an LD_PRELOAD shared library (installer/sandbox.c) that interposes libc entry points, notably a long syscall(long number, ...) wrapper that inspects the requested syscall number and raises a permission error for blacklisted calls. The vulnerable guard, called_from_python_import(), decided whether an open of a dynamic library was legitimate by walking the call stack with backtrace()/dladdr() and returning success whenever any frame's symbol name contained PyImport or _PyImport; otherwise it denied the dlopen. That is a heuristic, not an authorization decision, so an attacker could arrange for a Python import frame to be the most recent recognizable frame by triggering ctypes.CDLL from inside an importlib.abc.MetaPathFinder callback. Because ctypes itself loads through dlopen and dlsym, once the guard was satisfied the attacker could call dlsym(RTLD_NEXT, "syscall") to obtain the genuine glibc symbol, bypassing the LD_PRELOAD interposer entirely and thus the syscall blacklist, which is the CWE-693 protection-mechanism failure. The fix (commit d4bd22af8ba14a9dea317f9034332fec4e964697) removes the backtrace heuristic and instead denies any dlopen whose filename contains "_ctypes" when dynamic linking is disallowed (allow_dl_open != 1), and additionally, in apps/common/utils/tool_code.py, strips the sandbox user's read bit (0o040) from the _ctypes shared object (discovered via import _ctypes; _ctypes.__file__) so the module cannot be mapped at all when dlopen is prohibited. Note that because the sandbox is an in-process user-space interposer, defense ultimately depends on keeping the sandbox account unprivileged and on kernel-level confinement. CPE data (cpe:2.3:a:1panel-dev:maxkb:*:*:*:*:*:*:*) marks all MaxKB product versions as in scope with no version qualifier, consistent with the advisory covering every release before 2.10.6-lts.
Know when Maxkb 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
AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L
Authenticated member authoring sandbox code gives PR:L over the network (AV:N); the escape reliably defeats the blacklist (AC:L) yielding full file/process/network control within the sandbox user's authority (C/I/A:H, S:U).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
MaxKB is an open-source AI assistant for enterprise. Prior to version 2.10.6-lts, function-library code running under the LD_PRELOAD sandbox can invoke ctypes.CDLL from an importlib.abc.MetaPathFinder callback so the dlopen call-stack heuristic sees a Python import frame, then use unhooked dlsym with RTLD_NEXT to resolve glibc's real syscall and bypass the sandbox syscall blacklist. An authenticated workspace member can consequently read or write files, execute processes, or access networks as the sandbox user. This issue is fixed in version 2.10.6-lts.
Threat Intelligence Overview
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
MaxKB prior to version 1.10.8-lts contains an incomplete sandbox implementation that only blacklists binary execution in
Command injection in MaxKB before 2.10.5-lts allows unauthenticated remote attackers to execute arbitrary shell commands
Sandbox escape and privilege escalation in MaxKB 2.3.1 and earlier allow an attacker who can submit or trigger custom Py
Server-side request forgery in MaxKB before 2.10.0 allows any authenticated user holding the default workspace USER role
Authenticated workspace members on MaxKB deployments prior to 2.10.5-lts can escalate to root-level command execution by
OS command injection in MaxKB (1Panel-dev's open-source enterprise AI assistant) before 2.10.0-lts lets an authenticated
Server-side request forgery in MaxKB (open-source AI assistant from 1Panel-dev) allows an authenticated user with permis
Privilege escalation in MaxKB 2.3.1 and earlier allows an authenticated, low-privileged user to overwrite the built-in d
Authentication bypass in MaxKB (1Panel-dev) versions prior to 2.9.0 allows remote unauthenticated attackers to invoke we
Cross-workspace read and modification of model parameter defaults in MaxKB 2.10.3-lts and earlier is possible for an aut
MaxKB versions 2.7.1 and below allow authenticated users with tool execution privileges to bypass the LD_PRELOAD-based s
MaxKB versions 2.7.1 and below allow authenticated attackers with workspace privileges to execute arbitrary code by expl
EUVD-2026-84165
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB