/

CVE-2026-45327

Severity:

HIGH RISK

(8.2)

Missing Authentication (CWE-306) on WebRTC Ingest Endpoint in TinyIce Streaming Server

CVE-2026-45327

Deferred

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Unauthorized Stream Injection and Content Hijacking

Severity:

HIGH RISK

(8.2)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

TinyIce streaming server versions 0.8.95 through 2.4.1 expose a WebRTC ingest endpoint without proper authentication, allowing unauthenticated clients to inject audio/video streams into configured mounts.

Under these conditions, an attacker who can reach the ingest interface could push arbitrary content, potentially hijacking live channels, delivering unauthorized media, or enabling downstream abuse through the streaming pipeline.

Affected context

The vulnerability affects TinyIce deployments running versions 0.8.95 through 2.4.1 that:

  • Expose the WebRTC ingest endpoint to networks accessible by untrusted or semi-trusted clients
  • Rely on per-mount source passwords or default source passwords for ingest control
  • Do not have an additional external authentication or network-layer control in front of the ingest interface

An adjacent risk also exists on the POST /admin/golive/chunk endpoint where session-authenticated requests were not checked for per-mount authorization or CSRF protection, increasing the chance of misuse by authenticated but unauthorized or CSRF-coerced users.

Exploit preconditions

  • Attack surface: Network-accessible WebRTC ingest endpoint and /admin/golive/chunk administrative endpoint
  • Required access: Ability to reach the TinyIce HTTP/WebRTC interface over the network; no valid credentials are required for the vulnerable ingest path
  • Trigger point (WebRTC ingest):
  • Sending a WebRTC ingest request to the mount endpoint without presenting valid authentication
  • Exploitation is possible because the server accepts incoming streams without verifying the source password or applying rate-limited authentication checks
  • Trigger point (admin chunk endpoint):
  • The attacker has or can coerce a valid session (e.g., by CSRF or compromised account)
  • The server does not verify that the session user has authorization for the specific mount and does not enforce a CSRF token, enabling abuse of privileged operations
  • Why exploitation is possible: The design omits mandatory authentication and per-mount authorization checks on critical content-ingest paths, allowing control-plane operations to be executed without proving identity or intended privilege.

Why this happens

This issue stems from missing enforcement of authentication and authorization on critical endpoints responsible for ingesting and managing live streams.

For the WebRTC ingest path, the server was designed to accept connections and begin processing audio/video input without verifying a source password or applying existing authentication mechanisms. This maps to CWE-306: Missing Authentication for Critical Function, where a function that should require strong authentication is exposed without any or with incomplete checks.

For the adjacent /admin/golive/chunk endpoint, the root cause is a combination of:

  • Reliance on a generic session authentication without validating per-mount access controls
  • Lack of CSRF token verification to bind sensitive requests to deliberate user actions

Abstractly, this pattern is: "critical control endpoints for content and session management do not consistently enforce identity, fine-grained authorization, and request-origin verification," leading to unintended access paths for attackers.

Potential impact

  • Unauthorized injection of audio/video streams into live channels or mounts
  • Hijacking of existing streams, allowing attackers to replace legitimate content with arbitrary media
  • Distribution of malicious, illegal, or policy-violating content to downstream listeners or viewers
  • Reputational damage due to unexpected or offensive content being broadcast via the platform
  • Possible abuse of administrative endpoints to manipulate live sessions, timing, or chunks without proper authorization

General mitigation guidance

Effective mitigation focuses on enforcing strong, consistent authentication and authorization for all ingest and administrative endpoints.

Recommended defensive patterns include:

  • Requiring authentication (e.g., HTTP Basic, token-based, or equivalent) for all ingest endpoints and validating the supplied credentials against per-mount source secrets
  • Centralizing authorization logic so that every endpoint handling stream ingest or admin operations validates:
  • Whether the caller is authenticated
  • Whether the caller has rights to the specific mount or resource being targeted
  • Implementing password hashing and verification using well-reviewed algorithms (such as bcrypt) rather than comparing raw passwords directly
  • Enforcing rate limits and lockouts on failed authentication attempts to reduce brute-force risk
  • Applying defense-in-depth around admin interfaces:
  • CSRF protections for state-changing operations
  • Separation of duties and per-mount permissions to restrict what an authenticated user can modify
  • Hardening deployment by:
  • Restricting network exposure of ingest/admin endpoints (e.g., via IP allowlists, VPN, or reverse proxies)
  • Using configuration options to disable or isolate unused mounts and endpoints

These measures shift ingest and control endpoints toward secure-by-default operation, reducing the likelihood and impact of unauthorized stream injection.

How teams detect issues like this

Detection of this class of vulnerability and its exploitation can be approached from both code and operational perspectives.

Code and configuration review:

  • Examine routes/controllers handling ingest (e.g., WebRTC-specific endpoints) to confirm they:
  • Invoke authentication middleware
  • Validate mount-specific source passwords or tokens
  • Verify that admin endpoints:
  • Check both authentication and authorization for mount-specific actions
  • Enforce CSRF tokens on state-changing operations
  • Use static analysis or linting rules to flag:
  • Publicly accessible routes that bypass authentication or authorization
  • Security-critical handlers that do not reference shared auth components

Operational monitoring:

  • Monitor logs for:
  • Ingest requests originating from unexpected IP ranges or networks
  • Streams appearing on mounts without corresponding authenticated sessions or known source clients
  • Instrument security telemetry to:
  • Detect failed vs. successful ingest authentication attempts
  • Alert on unusual spikes in ingest traffic or mounts transitioning to live state unexpectedly
  • Use WAF or reverse-proxy rules to enforce authentication at the edge and log violations

Automated code review systems and CI-integrated security scanners can help surface missing authentication patterns by scanning route definitions for absent or inconsistent auth/CSRF/authorization checks.

Sources

SourceLink
github.comgithub.com/DatanoiseTV/tinyice/commit/8067d6b
github.comgithub.com/DatanoiseTV/tinyice/releases/tag/v2.5.0
github.comgithub.com/DatanoiseTV/tinyice/security/advisories/GHSA-p7c4-8x34-8j8f

Frequently asked

questions

Exploitability depends on how widely the WebRTC ingest and admin interfaces are exposed. If these endpoints are reachable from the public internet or semi-trusted networks, any remote party with network access may attempt unauthorized stream injection. In more restricted deployments (e.g., behind a VPN), exploitation would require access to those internal networks.

For the unauthenticated WebRTC ingest issue, no credentials are required; the endpoint accepts streams without verifying a source password. For the /admin/golive/chunk issue, an attacker would need a valid session or a way to coerce an authenticated user (such as via CSRF) into sending crafted requests, since the flaw lies in missing per-mount authorization and CSRF checks rather than in the absence of session authentication.

The safest pattern is to standardize all ingest and admin endpoints on a shared authentication and authorization framework. Every critical operation should:

  • Require explicit authentication
  • Validate per-resource (per-mount) permissions
  • Enforce CSRF protection for browser-originated state changes

Pairing this with secure password handling (hashed storage, vetted comparison libraries) and enforced rate limits significantly reduces the risk of unauthorized access and stream injection.

Prevention is best achieved by adopting a security-by-design approach:

  • Define a clear security policy for all routes (public vs. protected) and enforce it through centralized middleware
  • Require that any new endpoint that can change state, ingest content, or manage sessions must declare and pass explicit auth/authorization/CSRF requirements
  • Incorporate security-focused code review checklists that flag routes missing authentication or fine-grained access control
  • Use automated security testing (static analysis, integration tests, and configuration checks) to ensure consistent enforcement across versions and new features.
Find out what's already
exploitable in your codebase.