CVE-2026-55074

Executive Summary

CVE-2026-55074 is a symlink-following vulnerability in the Ansible FreeBSD Jail Connection Plugin ("jailexec") through version 1.3.0. When an operator runs a copy, template, or fetch-style task that uses the plugin's put_file function, the destination path is resolved on the jail host and mkdir -p and mv are executed there as root, following symbolic links that may exist inside the managed jail. This allows a party controlling content inside the jail (such as the jail's root or any process able to create a symlink in a target directory) to achieve an arbitrary root-owned write on the host outside the jail, resulting in a full jail escape.

Technical Analysis

The vulnerability resides in the put_file function of the jailexec connection plugin. In an Ansible architecture, a connection plugin is responsible for moving files to and executing commands on a managed node. For the FreeBSD Jail Connection Plugin, the managed node is a FreeBSD jail accessed via jexec. When put_file is invoked, the plugin resolves a transfer's destination to a path on the jail host — a path that is outside the jail's namespace — and then runs mkdir -p and mv at that location with root privileges on the host.

The core flaw is a classic link-following issue (CWE-59, Improper Link Resolution Before File Access). The mkdir -p and mv commands operate on the host-side path, and neither operation protects against symbolic links. If an attacker has already placed a symlink inside the jail at or above the destination path used by the Ansible task, the host-side, root-privileged mv will follow the symlink and write the file to the symlink's target on the host. Because the path is operated on outside the jail, the symlink effectively redirects the root-owned write to any location on the host filesystem writable by root.

The attack surface is the normal file-transfer workflow of the plugin. The precondition is twofold: the operator must run a task that uses put_file (e.g., copy, template, or fetch), and the attacker must be able to create a symlink inside the jail at or above the task's destination before the transfer executes. The jail's root, or any process with write access to a directory an Ansible task will later target, satisfies the attacker capability requirement.

No public proof-of-concept, exploit code, or Nuclei template exists for this CVE, and the issue has not been scored by FIRST.org (EPSS not available). The vulnerability is unpatched in all versions up to and including 1.3.0; version 2.0.0 contains the fix.

Exploitation Scenarios

No public PoC is available; the attack chain described below is inferred from the vulnerability class and the NVD description.

1. Reconnaissance / target identification: The attacker identifies a FreeBSD host running Ansible with the jailexec connection plugin (version <= 1.3.0) and determines which jails are managed by the operator. The attacker must already control content inside a managed jail — either as the jail's root or as a process with write access to a directory that an Ansible task will later write to.

2. Triggering the flaw (CWE-59 link following): The attacker places a symbolic link inside the jail. The symlink is positioned at or above the destination path that a future Ansible copy, template, or fetch task will use. When the operator runs that task, put_file resolves the destination to a host-side path and executes mkdir -p and mv there as root. Because these commands follow symbolic links and the path is outside the jail, the mv follows the attacker's symlink to an arbitrary target location on the host.

3. Payload/execution method: The write itself is an arbitrary root-owned file write on the host, outside the jail. The content written is the file transferred by the Ansible task. The attacker does not execute code directly through this step; the impact is the ability to place attacker-influenced or attacker-chosen content at a root-owned path of the attacker's choosing on the host filesystem.

4. Post-exploitation impact: The arbitrary root-owned host write is readily escalated to full host compromise. As noted in the NVD description, targets such as cron jobs, rc.d scripts, and authorized_keys can be overwritten or created, yielding code execution as root on the host or persistent SSH access. This constitutes a complete jail escape — the attacker moves from confined jail access to control of the underlying host.

Impact Assessment

This is a high-impact local privilege-escalation and container/jail-escape vulnerability. A successful exploit grants an attacker arbitrary root-owned write on the jail host, which is directly convertible to host-level code execution and persistence. The scope is changed relative to the typical jail boundary: while the attacker's initial position is inside the jail, the impact manifests on the host, outside the isolation boundary the jail is meant to enforce.

Using CVSS v3.1 subscores as a framework: the attack vector is local (AV:L) because the attacker must have a foothold inside the managed jail; attack complexity is low (AC:L) because no special conditions beyond the preconditions are required; privileges required are low (PR:L) since jail root or a process with directory write access suffices; user interaction is required (UI:R) because an operator must run the file-transfer task; scope is changed (S:C) because the vulnerable component's impact crosses the jail/host security boundary; confidentiality, integrity, and availability impacts are all high (C:H/I:H/A:H) given arbitrary root-owned host writes.

The blast radius is every FreeBSD host running the jailexec plugin (<= 1.3.0) with jails whose contents are not fully trusted. Organizations using FreeBSD jails as a multi-tenant or untrusted-workload isolation boundary and driving them with Ansible are most exposed. The CVSS score is listed as N/A in the provided data and no official vector is published; the vector shown in the metadata is a framework-based estimate derived from the description, not an authoritative vendor or NVD score.

Detection Guidance

Sigma Rule

title: Potential CVE-2026-55074 FreeBSD Jail Escape via Symlinked Ansible File Transfer
id: 7f3a9c2e-1b4d-4e6a-9c8f-2d5a1e0b7c33
status: experimental
description: Detects root-privileged mv/mkdir operations on host paths consistent with the jailexec put_file symlink-following jail escape.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-55074
author: Threat Intelligence
date: 2026-01-01
logsource:
  product: linux
  category: process_creation
detection:
  selection_parent:
    ParentImage|endswith:
      - '/jexec'
      - 'ansible'
      - 'ansible-playbook'
  selection_cmd:
    Image|endswith:
      - '/mv'
      - '/mkdir'
    CommandLine|contains:
      - 'mkdir -p'
      - 'mv '
  selection_path:
    CommandLine|contains:
      - '/jails/'
      - '/usr/local/jails/'
      - '/jail/'
  condition: selection_parent and selection_cmd and selection_path
fields:
  - CommandLine
  - ParentImage
falsepositives:
  - Legitimate Ansible file transfers into jails that do not traverse symlinks
level: high
tags:
  - attack.t1611
  - cve.2026.55074

YARA Rule

rule CVE_2026_55074_Jailexec_Jail_Escape
{
    meta:
        description = "Detects jailexec put_file symlink-following jail escape indicators in Ansible playbooks/plugin artifacts"
        author = "Threat Intelligence"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-55074"
        date = "2026-01-01"
        cve = "CVE-2026-55074"

    strings:
        $plug = "jailexec" ascii nocase
        $put  = "put_file" ascii nocase
        $jexec = "jexec" ascii
        $mv    = "mv " ascii
        $mkdir = "mkdir -p" ascii
        $sym1  = "os.symlink" ascii nocase
        $sym2  = "lstat" ascii nocase
        $jail1 = "/jails/" ascii
        $jail2 = "/usr/local/jails/" ascii

    condition:
        $plug and $put and (2 of ($jexec, $mv, $mkdir)) and ($sym1 or $sym2 or $jail1 or $jail2)
}

Suricata IDS Rule

alert tcp $HOME_NET any -> $HOME_NET 22 (msg:"CVE-2026-55074 Ansible jailexec put_file Jail Escape Attempt (symlink redirect)"; flow:to_server,established; content:"put_file"; nocase; content:"jexec"; nocase; content:"/jails/"; nocase; reference:cve,2026-55074; classtype:attempted-admin; metadata:affected_product Ansible, attack_target Server, deployment Perimeter, signature_severity Critical, created_at 2026_01_01, cve CVE_2026_55074; sid:202655074; rev:1;)

Elastic Detection

process where event.type == "start" and
  process.parent.name in ("ansible", "ansible-playbook", "jexec") and
  process.name in ("mv", "mkdir") and
  process.args : ("*mkdir -p*", "*mv *") and
  process.args : ("*/jails/*", "*/usr/local/jails/*", "*/jail/*")

Splunk SPL Query

index=os sourcetype=process_creation
| search (Image="*/mv" OR Image="*/mkdir")
| search CommandLine="*mkdir -p*" OR CommandLine="*mv *"
| search CommandLine="*/jails/*" OR CommandLine="*/usr/local/jails/*" OR CommandLine="*/jail/*"
| where match(ParentImage, "(?i)(ansible|jexec)")
| eval risk="CVE-2026-55074 potential jail escape"
| table _time host user ParentImage Image CommandLine risk
| sort - _time

Wazuh OSSEC Rule

<group name="ansible,jailexec,cve_2026_55074,">
  <rule id="100574" level="12">
    <if_sid>59200</if_sid>
    <field name="ParentImage">ansible|jexec|ansible-playbook</field>
    <field name="Image">mv|mkdir</field>
    <match>mkdir -p|mv </match>
    <regex>/jails/|/usr/local/jails/|/jail/</regex>
    <description>CVE-2026-55074: Potential FreeBSD jail escape via jailexec put_file symlink-following host-side root write</description>
    <mitre>
      <id>T1611</id>
    </mitre>
    <group>privilege_escalation,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source).

1. Immediate mitigations:

   • Upgrade the Ansible FreeBSD Jail Connection Plugin to version 2.0.0 or later, which contains the fix. This is the primary and recommended remediation.
   • Until upgrade is possible, avoid or restrict use of copy, template, and fetch-style tasks (anything relying on put_file) against untrusted jails.
   • Reduce attacker capability inside jails: ensure non-root processes in managed jails cannot create symbolic links in directories that Ansible tasks later write to. Treat any jail whose contents are attacker-controllable as trusted-host-compromising.
   • Where feasible, run Ansible file-transfer operations against jails with the least host privilege possible, and audit host-side paths the plugin resolves to for unexpected symlinks.

2. Patch/upgrade steps:

   • Identify hosts running the jailexec plugin with version <= 1.3.0.
   • Install jailexec 2.0.0 or later and re-run validation playbooks against a test jail.
   • Confirm no earlier pinned versions remain in dependency manifests or requirements files.

3. Long-term hardening:

   • Treat FreeBSD jails driven by Ansible as a shared security boundary only when the jail contents are fully trusted; otherwise adopt additional isolation.
   • Monitor for and alert on root-privileged host-side mv/mkdir operations touching jail paths.
   • Enforce principle of least privilege for automated file transfers and periodically review host-side target paths for symlink abuse.

References

• NVD: https://nvd.nist.gov/vuln/detail/CVE-2026-55074
• CWE-59 — Improper Link Resolution Before File Access ('Link Following'): https://cwe.mitre.org/data/definitions/59.html
• MITRE ATT&CK T1611 — Escape to Host: https://attack.mitre.org/techniques/T1611/
• Ansible FreeBSD Jail Connection Plugin (project/repository for the jailexec plugin; consult for the 2.0.0 release)
• CISA Known Exploited Vulnerabilities Catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (CVE-2026-55074 is NOT listed)

No public PoC, exploit code, Nuclei template, or known in-the-wild campaign has been observed for CVE-2026-55074 as of the provided data.