CVE-2023-43800

Executive Summary

CVE-2023-43800 is a privilege escalation vulnerability in the Arduino Create Agent, a background service package used to manage Arduino development workflows. The flaw resides in the /v2/pkgs/tools/installed endpoint, where insufficient verification of data authenticity permits an attacker — who can make HTTP requests to the localhost interface or bypass CORS protections — to escalate privileges to those of the user running the service. The issue is addressed in version 1.3.3, and no workarounds exist. Given the localhost attack surface and the requirement of existing local access or CORS bypass, the practical exposure is limited but severe when triggered, as it grants full account-level control of the service process.

Technical Analysis

Arduino Create Agent is a helper service installed alongside Arduino IDE and related tooling, listening on localhost to handle package management and board/toolchain operations. The affected endpoint, /v2/pkgs/tools/installed, is used to list and manage installed tool packages.

The vulnerability class is Insufficient Verification of Data Authenticity (CWE-345). This category indicates that the product does not sufficiently verify the origin or integrity of data it receives — in this case, HTTP POST requests submitted to the localhost endpoint. The core flaw: a local process (or any requester capable of reaching the localhost interface) can issue a crafted HTTP POST to this endpoint, and the agent will process the request without validating that the request is genuinely from the legitimate Arduino application/user session, nor verifying that the data is authentic/authorized.

Because the service runs with the privileges of the logged-in user, successful exploitation means an attacker-controlled request is processed as if it originated from the legitimate user context. This allows the attacker to perform privileged operations — such as installing, replacing, or manipulating tool packages — effectively escalating to the full privileges of the account running the service.

Attack surface specifics:

• Local attack vector: Any process running as the same user, or any lower-privileged process able to issue HTTP requests to localhost, can reach this endpoint.
• CORS bypass: The service has a CORS configuration; if an attacker can bypass it (e.g., via a malicious web page in the victim's browser, or via a DNS rebinding attack), the endpoint becomes reachable remotely.
• No authentication evident: The NVD description does not indicate any token, secret, or per-request signature requirement, which aligns with CWE-345.

Limited technical details are available regarding the exact parsing logic or payload structure. However, the vulnerability mechanism is clear: unauthenticated/unverified POST requests to /v2/pkgs/tools/installed are processed with the service's privileges.

Exploitation Scenarios

Prerequisites:

• Attacker must be able to issue HTTP requests to the localhost interface (e.g., through code execution on the same machine, a malicious browser tab, or a DNS rebinding attack to bypass CORS).
• Arduino Create Agent version < 1.3.3 must be installed and running.

Attack Chain (inferred from vulnerability class):

1. Reconnaissance / Target Identification

   • The attacker identifies a machine running Arduino Create Agent (process name: arduino-create-agent or similar).
   • Reconnaissance: probe http://localhost:PORT/v2/pkgs/tools/installed — if a valid HTTP response is received (e.g., 200 with JSON body), the service is confirmed present and vulnerable.

2. Flaw Trigger

   • The attacker crafts an HTTP POST request to /v2/pkgs/tools/installed.
   • Since no authenticity verification is performed, the request is accepted regardless of whether it originates from the legitimate Arduino application, a malicious local process, or a browser-side script that bypassed CORS.

3. Payload / Execution Method

   • The attacker manipulates the POST body (e.g., JSON payload) to instruct the agent to perform tool operations such as:
     • Installing a malicious tool package (e.g., replacing a compiler with a trojanized binary).
     • Modifying installed package metadata to redirect future downloads to attacker-controlled URLs.
     • Deleting or corrupting existing tool packages to disrupt the environment.
   • The exact payload structure (field names, JSON schema) is not public; the attack is described at the vulnerability-class level.

4. Post-Exploitation Impact

   • Since the agent runs with the user's full privileges, the attacker now has the ability to execute arbitrary code with the victim user's privileges — by having the agent install and invoke a malicious package.
   • This enables: data exfiltration from user directories, credential theft, persistence via modified toolchains, lateral movement (if the user has elevated network access).

No public PoC available; attack chain is inferred from vulnerability class. The exploitation is plausible and straightforward for anyone with local code execution or browser-based CORS bypass capability.

Impact Assessment

CVSS Score: 7.3 (High). The vector approximates to: Local attack vector, Low complexity, Low privileges required, User interaction required (for browser-based CORS bypass), Unchanged scope, High confidentiality/integrity/availability impact.

Business Impact:

• Confidentiality (High): An attacker can read files accessible to the target user by installing malicious tooling that exfiltrates data.
• Integrity (High): Tool packages can be replaced with trojanized binaries, compromising the build chain and introducing supply-chain risks to any software developed using the compromised environment.
• Availability (High): The agent's tools can be deleted or corrupted, breaking the development environment.

Affected Systems:

• All installations of Arduino Create Agent prior to version 1.3.3.
• Primarily desktop/laptop environments (Windows, macOS, Linux) where Arduino IDE/tooling is used by developers, hobbyists, and embedded engineers.
• Additionally, CI/CD pipelines that leverage Arduino CLI/agent containers (if the service is exposed) are at risk.

Blast Radius:

• Local system: Full compromise of the user account running the agent.
• Supply chain: If the victim organization develops firmware/embedded products, a compromised toolchain can result in backdoored firmware being shipped to end customers.
• Data exposure: Source code, credentials stored in IDE configs, and sensitive project files accessible to the compromised user account can be exfiltrated.

EPSS score (0.00211, ~11.5th percentile) indicates low current exploitation likelihood — this vulnerability is not part of any known mass-exploitation campaign to date.

Detection Guidance

Sigma Rule

title: Arduino Create Agent - Privilege Escalation via Unauthenticated POST to /v2/pkgs/tools/installed
id: 9f2b5e6c-7a11-4f3d-9e6a-123456789abc
status: experimental
description: Detects HTTP POST requests to the Arduino Create Agent package management endpoint, which may indicate privilege escalation attempts (CVE-2023-43800).
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2023-43800
author: Valtersit Threat Intelligence
date: 2024/01/15
logsource:
    category: webserver
    product: arduino_create_agent
detection:
    selection:
        http.method: POST
        http.url: /v2/pkgs/tools/installed
        http.response.status_code: 2*
    condition: selection
level: high
falsepositives:
    - Legitimate Arduino IDE operations when it syncs installed tools list.
    - Arduino CLI commands that refresh tool inventory.
tags:
    - attack.privilege_escalation
    - cve.2023-43800
    - cwe.345

YARA Rule

rule Arduino_Create_Agent_CVE_2023_43800_PostRequest
{
    meta:
        author = "Valtersit Threat Intelligence"
        description = "Detects crafted HTTP POST request targeting /v2/pkgs/tools/installed"
        cve = "CVE-2023-43800"
        date = "2024-01-15"
        severity = "high"
    strings:
        $url = "/v2/pkgs/tools/installed"
        $post = "POST"
        $json = "Content-Type: application/json"
        // Common JSON keys for package manipulation (inferred)
        $key1 = "\"name\"" ascii nocase
        $key2 = "\"version\"" ascii nocase
        $key3 = "\"action\"" ascii nocase
    condition:
        uint16(0) == 0x4d5a or uint32(0) == 0x464c457f
        and $url and $post and $json
        and 1 of ($key*)
}

Note: The YARA rule targets network captures of malicious POST bodies; for filesystem/process memory detection, run on pcap files or live network streams.

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2023-43800: Arduino Create Agent Privilege Escalation - POST to /v2/pkgs/tools/installed"; flow:established,to_server; http.method; content:"POST"; http.uri; content:"/v2/pkgs/tools/installed"; http.request_body; pcre:"/(?:name|version|action|tool|package|install|uninstall|url)/i"; classtype:attempted-admin; sid:2023438001; rev:1; metadata:cve CVE-2023-43800, cwe CWE-345, severity high;)

Rationale: This rule triggers on any POST to the sensitive endpoint with a JSON-looking body containing package manipulation keys. Due to the low false-positive rate of this specific URI + method combination, the broader body regex is acceptable.

Elastic Detection

any where
  event.category == "http" and
  http.request.method == "POST" and
  http.request.url == "/v2/pkgs/tools/installed" and
  http.response.status_code < 300

Elasticsearch Query (alternative):

{
  "query": {
    "bool": {
      "must": [
        { "match": { "http.request.method": "POST" } },
        { "match": { "http.request.url": "/v2/pkgs/tools/installed" } }
      ],
      "filter": [
        { "range": { "http.response.status_code": { "lt": 300 } } }
      ]
    }
  }
}

Splunk SPL Query

index=web sourcetype=access_combined
| where method="POST" AND uri="/v2/pkgs/tools/installed"
| where status>=200 AND status<300
| eval threat="CVE-2023-43800 Arduino Create Agent Privilege Escalation"
| table _time, src_ip, user, uri, status, bytes

Wazuh OSSEC Rule

<group name="arduino_create_agent,">
    <rule id="221719" level="12">
        <if_sid>31199</if_sid> <!-- HTTP POST event (adapt to your environment) -->
        <match>/v2/pkgs/tools/installed</match>
        <options>nocase</options>
        <description>Arduino Create Agent - Potential privilege escalation via POST to /v2/pkgs/tools/installed (CVE-2023-43800)</description>
        <group>privilege_escalation,</group>
        <mitre>
            <id>T1068</id>
        </mitre>
    </rule>
</group>

Mitigation & Patch Guidance

Patch Confidence: 3/4 — LIKELY. Two independent sources (CNA and OSV) confirm the fix in version 1.3.3. The patch addresses the authentication/verification gap on the /v2/pkgs/tools/installed endpoint.

Immediate Mitigations (0–7 days):

1. Upgrade to 1.3.3+ — the only reliable mitigation. No workarounds exist.
2. Block external/localhost access: If upgrade is not immediately possible, restrict access to the endpoint by:
   • Using a host-based firewall to block requests to the Arduino Create Agent listening port from any unknown local process.
   • Ensuring the agent binds only to 127.0.0.1 (do not expose on 0.0.0.0).
3. Harden browser posture: Since CORS bypass is a secondary vector, disable DNS rebinding protections in the browser and consider adding X-Content-Type-Options: nosniff and strict CORS headers if proxying the agent.

Patch/Upgrade Steps:

1. Identify the current version: arduino-create-agent --version (or check the package manager entry).
2. Upgrade via the Arduino IDE package manager or directly:
   • macOS/Linux: curl -fsSL https://raw.githubusercontent.com/arduino/arduino-create-agent/main/install.sh | sh
   • Windows: Download the latest setup executable from the official Arduino repository.
   • Or use your package manager if Arduino is installed via brew, apt, etc.
3. Restart the agent service after upgrade to ensure the new version is loaded.
4. Verify the upgrade: arduino-create-agent --version should report 1.3.3 or higher.

Long-Term Hardening:

1. Monitor vendor advisories — this is CWE-345 (insufficient verification); audit other endpoints in the agent for similar missing-authentication issues.
2. Run the agent in a sandbox/container, minimizing the privileges of the user account it runs under.
3. Enable file integrity monitoring on tool package directories to detect unauthorized replacement of binaries.
4. Deploy runtime detection: Use the Sigma/Suricata/Elastic rules above in your SIEM/IDS to monitor for POSTs to this endpoint.
5. Network segmentation: If the agent is used in CI/CD, ensure the build environment is ephemeral and isolated.

References

1. NVD Entry: https://nvd.nist.gov/vuln/detail/CVE-2023-43800
2. OSV Advisory: https://osv.dev/vulnerability/CVE-2023-43800
3. Arduino GitHub Repository (fix commit): https://github.com/arduino/arduino-create-agent/releases/tag/1.3.3
4. CWE-345 Reference: https://cwe.mitre.org/data/definitions/345.html
5. MITRE ATT&CK — T1068 Exploitation for Privilege Escalation: https://attack.mitre.org/techniques/T1068/

Threat Actor Activity / Exploit-in-the-Wild Evidence:

• No known threat actor campaigns currently leverage CVE-2023-43800.
• CISA KEV status: NO (not listed in Known Exploited Vulnerabilities catalog).
• No public PoC or exploit code exists at the time of writing. The localhost-only attack surface limits remote exploitation likelihood, but the low EPSS percentile (11.5%) supports a low active exploitation rate.