CVE-2021-44547

Executive Summary

CVE-2021-44547 is a sandboxing bypass vulnerability in Odoo Community 15.0 and Odoo Enterprise 15.0 that enables authenticated administrators to execute arbitrary code, resulting in privilege escalation. The flaw resides in the insufficient isolation of automated operations, allowing a privileged user to escape the intended sandbox constraints and run arbitrary system commands. The vulnerability carries a CVSS score of 8.7, indicating high severity, and while no public exploit code is currently available, the affected Odoo 15.0 installations remain exposed to post-authentication compromise. Enterprise security teams managing Odoo deployments should prioritize patching and implementing monitoring controls.

Technical Analysis

The NVD description for CVE-2021-44547 states: "A sandboxing issue in Odoo Community 15.0 and Odoo Enterprise 15.0 allows authenticated administrators to executed arbitrary code, leading to privilege escalation." The description is brief; no specific function names, classes, file paths, or API endpoints are provided in the NVD entry or CNA title.

The vulnerability is classified as a sandboxing issue. Odoo's architecture relies on a sandboxed execution environment for certain automated operations — most notably the "Automated Actions" (server actions) feature, which allows administrators to define Python code snippets that run in response to record creation, modification, or deletion events. These snippets are designed to run within a restricted Python environment that limits access to the file system, network, and certain built-in modules.

The flaw allows an authenticated administrator to escape this sandboxed environment and execute arbitrary code with the privileges of the Odoo server process. Because the attacker must already be an authenticated administrator, the privilege escalation component refers to transitioning from administrative control within the Odoo application itself to arbitrary code execution on the underlying operating system. In typical on-premise deployments, this means the attacker gains the ability to execute commands as the user running the Odoo service — often a dedicated system account but potentially root or a user with broader system privileges depending on the deployment configuration.

The attack surface is restricted to authenticated administrative users. This reduces the external exposure but does not eliminate risk: administrators with malicious intent, compromised administrator accounts, or lateral movement scenarios where an attacker has obtained low-privilege Odoo access and subsequently escalated to admin within the application can all leverage this flaw. The sandbox escape mechanism likely involves abusing Python's dynamic features — such as introspection, descriptor protocol, or restricted built-in bypass techniques — but without further technical detail from the CNA, specific exploitation vectors cannot be enumerated.

Insufficient technical detail is available from the NVD entry to describe the precise mechanism of the sandbox escape.

Exploitation Scenarios

No public PoC is available; the attack chain is inferred from the vulnerability class (sandbox escape) and the Odoo feature set.

Step 1 — Reconnaissance / Target Identification: The attacker identifies an Odoo instance running version 15.0 (Community or Enterprise). This can be achieved through HTTP fingerprinting (Odoo serves identifiable web page structures and version strings in its login page source or /web/login responses), or through Shodan/Censys queries for Odoo web interfaces. The attacker then establishes a valid administrative session, either through legitimate credentials, a compromised admin account, or internal lateral movement.

Step 2 — Flaw Trigger: The attacker navigates to the Odoo backend administrative interface and locates the Automated Actions configuration (typically under Settings → Technical → Automated Actions). They create or modify a server action that contains malicious Python code designed to escape the sandbox. The code may attempt to access restricted built-in functions, traverse Python object hierarchies, or abuse module import mechanisms that the sandbox should have filtered.

Step 3 — Payload / Execution Method: The payload is crafted at the vulnerability-class level: a Python script embedded in the automated action definition. Upon triggering the action (e.g., creating, writing, or deleting a record that the action listens to), the Odoo server evaluates the code within the sandbox. The sandbox bypass logic executes, and the injected code runs outside the intended restrictions. The attacker's code can then invoke system commands via available OS-level functions or Python standard library modules accessible after the escape.

Step 4 — Post-Exploitation Impact: Once arbitrary code execution is achieved, the attacker operates with the OS privileges of the Odoo server process. Typical post-exploitation actions include: reading configuration files (database credentials, mail server credentials), exfiltrating Odoo database contents (customer data, financial records, intellectual property), establishing persistence via cron jobs or SSH keys, deploying ransomware, or pivoting to other systems on the internal network. The privilege escalation is complete — from Odoo-level administrative control to system-level command execution.

Note: No public PoC exists at the time of this report. This chain is a logical reconstruction based on the sandbox-escape vulnerability class and Odoo's documented admin features. Specific function names and implementation details of the bypass are unknown.

Impact Assessment

The CVSS score of 8.7 (High) reflects the severity of this vulnerability. While the attack requires authenticated administrative access (reducing the attack surface), the impact — arbitrary code execution on the host operating system — is severe. The confidentiality and integrity impact are both rated as high, as the attacker can read, modify, and delete any data accessible to the Odoo service account. Availability is also at risk if the attacker chooses to disrupt the service.

Affected systems: All Odoo Community 15.0 and Odoo Enterprise 15.0 installations.

Blast radius: In on-premise deployments, the blast radius extends beyond the Odoo application. The Odoo server typically holds database credentials, SMTP credentials, and often resides on the internal corporate network, enabling lateral movement. In containerized or multi-tenant deployments, a sandbox escape could potentially compromise the underlying host or adjacent containers.

Business impact: Data breach (customer PII, financial data, trade secrets), regulatory compliance violations (GDPR, HIPAA, PCI-DSS), reputational damage, operational disruption. The privilege escalation aspect means that even organizations with a robust "least privilege" admin model are fully compromised if any single Odoo admin account is compromised.

EPSS note: The EPSS score of 0.00695 (49.5th percentile) indicates that exploitation in the wild is currently unlikely but not impossible. The absence of public PoC and the lack of CISA KEV listing suggest this is not yet an actively exploited vulnerability. However, sandbox escapes in widely deployed Erp platforms are historically prone to PoC publication by security researchers and red teams.

Detection Guidance

Sigma Rule

title: Odoo Automated Action Sandbox Escape Attempt
id: 8f2c1b4a-9d3e-4f6a-8b2c-3d4e5f6a7b8c
status: experimental
description: Detects creation or modification of Odoo automated actions containing suspicious Python code patterns indicative of sandbox escape attempts
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2021-44547
author: Valtersit Threat Intelligence
date: 2024/01/15
tags:
  - attack.t1204
  - attack.execution
  - attack.privilege_escalation
logsource:
  category: application
  product: odoo
detection:
  selection:
    event_type: 'server_action'
    action_type: 'python'
  keywords:
    - '__builtins__'
    - '__import__'
    - 'os.system'
    - 'subprocess'
    - '__subclasses__'
    - '__globals__'
    - 'eval('
    - 'exec('
    - 'open('
  condition: selection and keywords
fields:
  - user_id
  - model
  - action_name
  - code
falsepositives:
  - Legitimate advanced Odoo server actions using introspection
level: high

YARA Rule

rule Odoo_Sandbox_Escape_CVE_2021_44547
{
    meta:
        author = "Valtersit Threat Intelligence"
        description = "Detects Python code patterns used in Odoo sandbox escape attempts"
        cve = "CVE-2021-44547"
        date = "2024-01-15"
    strings:
        $s1 = "os.system" ascii nocase
        $s2 = "subprocess" ascii nocase
        $s3 = "__builtins__" ascii
        $s4 = "__globals__" ascii
        $s5 = "__subclasses__" ascii
        $s6 = "class.mro" ascii
        $s7 = ".__code__" ascii
        $s8 = "gc.get_objects" ascii
        $s9 = "ctypes" ascii nocase
        $s10 = "eval(" ascii
        $s11 = "exec(" ascii
    condition:
        (uint16(0) == 0x0D0A or uint16(0) == 0x0A0D) and
        any of ($s1, $s2, $s3, $s4, $s5) and
        any of ($s6, $s7, $s8, $s9) or
        (any of ($s10, $s11) and any of ($s3, $s4, $s5))
}

Suricata IDS Rule

alert http any any -> $HOME_NET any (msg:"Odoo CVE-2021-44547 Sandbox Escape Attempt"; flow:to_server,established; content:"/web/dataset/call_kw"; http.uri; content:"server_action"; http.uri; content:"python"; http.uri; content:"__builtins__|os.system|subprocess|__subclasses__|__globals__"; pcre:"/(__builtins__|os\.system|subprocess|__subclasses__|__globals__)/i"; classtype:attempted-admin; sid:2024447; rev:1; reference:cve,2021-44547;)

Note: The rule targets HTTP POST requests to Odoo's RPC endpoints that include Python code patterns in the JSON body. Adjust $HOME_NET and HTTP URI patterns to match your Odoo deployment.

Elastic Detection

sequence by winlog.event_data.ProcessId with maxspan=5m
  [file where process.name : "odoo-bin" and
   file.extension : ("py", "pyc") and
   file.name : "*action*" and
   file.path : "*server_actions*"]
  [process where process.name : ("bash", "sh", "python3", "perl", "php") and
   process.command_line : ("*curl*", "*wget*", "*base64*", "*/etc/passwd*", "*/bin/sh*")]

# Alternative: detect suspicious Python code content in Odoo actions
any where event.module == "odoo" and
  event.action == "server_action.execute" and
  code.language == "python" and
  (
    code.text contains "__builtins__" or
    code.text contains "os.system" or
    code.text contains "subprocess" or
    code.text contains "__subclasses__" or
    code.text contains "__globals__" or
    code.text contains "eval(" or
    code.text contains "exec("
  )

Splunk SPL Query

index=odoo sourcetype=odoo:log 
| search "server_action" AND ("__builtins__" OR "os.system" OR "subprocess" OR "__subclasses__" OR "__globals__" OR "eval(" OR "exec(" OR "open(")
| stats count by user, model, action_name, src_ip, _time
| sort - _time
| table _time, user, model, action_name, src_ip, count

# For Windows-based Odoo deployments - process execution detection
index=windows EventCode=4688
| search NewProcessName IN ("*bash*", "*sh*", "*python*", "*cmd*")
| join process_id [search index=odoo sourcetype=odoo:log "server_action"]
| table _time, user, src_ip, NewProcessName, CommandLine, ProcessId, ParentProcessId

Wazuh OSSEC Rule

<rule id="100447" level="12">
  <decoded>json</decoded>
  <field name="event_type" type="pcre">server_action</field>
  <field name="action_type" type="pcre">python</field>
  <description>Odoo: Python automated action contains suspicious sandbox escape patterns (CVE-2021-44547)</description>
  <mitre>
    <id>T1204</id>
    <id>T1068</id>
  </mitre>
  <group>odoo, exploitation, privilege_escalation,</group>
</rule>

<rule id="100448" level="12">
  <if_sid>100447</if_sid>
  <regex>__builtins__|os\.system|subprocess|__subclasses__|__globals__|eval\(|exec\(</regex>
  <description>Odoo: confirmed sandbox escape indicators in server action code</description>
  <group>odoo, exploitation,</group>
</rule>

Mitigation & Patch Guidance

Patch confidence: 2/4 — CLAIMED. The patch is claimed by a single source (Debian) and is not independently confirmed by Odoo's official advisory channels at the time of this report.

1) Immediate Mitigations:

• Restrict Admin Access: Limit the number of users with Odoo administrative privileges. Enforce strong authentication (MFA) on all admin accounts since the vulnerability requires authenticated admin access.
• Network Isolation: Place Odoo 15.0 instances on a segmented network segment. Restrict outbound egress from the Odoo server to prevent data exfiltration if compromised.
• Monitor Automated Actions: Manually review all existing and newly-created automated actions containing Python code. Adopt a change-management process requiring peer review before any Python server action is deployed.
• Least Privilege for Service Account: Ensure the Odoo service runs under a minimally-privileged OS account. Never run Odoo as root or SYSTEM. Restrict file system access for this account to only required directories.

2) Patch/Upgrade Steps:

• Check the Debian security tracker for the specific version of odoo package that addresses CVE-2021-44547.
• Apply the fix by running apt-get update && apt-get install --only-upgrade odoo on Debian-based systems.
• For non-Debian deployments, monitor Odoo's official security advisory page (https://www.odoo.com/security) for a confirmed fix. If no official patch is available, upgrade to Odoo 16.0 or later where this sandboxing issue is believed to be addressed (verify with Odoo's release notes).
• Validate the patch: After upgrading, re-test automated actions with sandbox-escape payloads to confirm the sandbox restrictions are enforced correctly.

3) Long-Term Hardening:

• Maintain a regular upgrade cadence for Odoo instances. Do not run EOL or outdated versions.
• Implement a Web Application Firewall (WAF) with Odoo-specific rules to inspect POST body for Python code patterns.
• Enable comprehensive logging at the application level, capturing all server action executions, including user, model, and code hash.
• Implement a file integrity monitoring (FIM) solution to detect unauthorized changes to Odoo module files and automated action definitions.
• Establish a threat-hunting workflow in the SIEM to proactively search for sandbox-escape patterns in Odoo logs (see Detection Guidance above).

References

1. NVD Entry: https://nvd.nist.gov/vuln/detail/CVE-2021-44547
2. Debian Security Tracker: https://security-tracker.debian.org/tracker/CVE-2021-44547
3. Odoo Security Page (official advisory): https://www.odoo.com/security
4. Odoo Community Association (OCA) Security Discussion Forum: https://github.com/odoo/odoo/issues (search for CVE-2021-44547)
5. MITRE CVE Registry: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44547

Threat Actor / Exploit-in-the-Wild Evidence: No known threat actor campaigns, exploit-in-the-wild usage, or CISA KEV inclusion has been recorded for CVE-2021-44547 as of this report. The EPSS score (0.00695) and absence of public PoC indicate a low immediate exploitation likelihood. However, sandbox-escape vulnerabilities in Odoo have historically attracted researcher attention, and PoC publication should be anticipated. Monitor the GitHub advisory database and exploit-db for future disclosures.