mirror of
https://github.com/UrloMythus/UnHided.git
synced 2026-06-10 09:10:23 +00:00
UrloMythus
903 lines
35 KiB
Python
903 lines
35 KiB
Python
import asyncio
|
|
import ipaddress
|
|
import logging
|
|
import re
|
|
from functools import lru_cache
|
|
from typing import Annotated
|
|
from urllib.parse import quote, unquote, urlparse
|
|
|
|
import aiohttp
|
|
from aiohttp import ClientTimeout
|
|
from fastapi import Request, Depends, APIRouter, Query, HTTPException, Response
|
|
from fastapi.datastructures import QueryParams
|
|
|
|
from mediaflow_proxy.configs import settings
|
|
from mediaflow_proxy.handlers import (
|
|
handle_hls_stream_proxy,
|
|
handle_stream_request,
|
|
proxy_stream,
|
|
get_manifest,
|
|
get_playlist,
|
|
get_segment,
|
|
get_init_segment,
|
|
get_public_ip,
|
|
)
|
|
from mediaflow_proxy.schemas import (
|
|
MPDSegmentParams,
|
|
MPDPlaylistParams,
|
|
HLSManifestParams,
|
|
MPDManifestParams,
|
|
MPDInitParams,
|
|
)
|
|
from mediaflow_proxy.utils.base64_utils import process_potential_base64_url
|
|
from mediaflow_proxy.utils.extractor_helpers import (
|
|
check_and_extract_sportsonline_stream,
|
|
)
|
|
from mediaflow_proxy.utils.hls_prebuffer import hls_prebuffer
|
|
from mediaflow_proxy.utils.http_client import create_aiohttp_session
|
|
from mediaflow_proxy.utils.http_utils import (
|
|
get_proxy_headers,
|
|
ProxyRequestHeaders,
|
|
apply_header_manipulation,
|
|
)
|
|
from mediaflow_proxy.utils.stream_transformers import apply_transformer_to_bytes
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
proxy_router = APIRouter()
|
|
|
|
|
|
@lru_cache(maxsize=1)
|
|
def _load_transcode_components():
|
|
from mediaflow_proxy.remuxer.media_source import HTTPMediaSource
|
|
from mediaflow_proxy.remuxer.transcode_handler import (
|
|
handle_transcode,
|
|
handle_transcode_hls_init,
|
|
handle_transcode_hls_playlist,
|
|
handle_transcode_hls_segment,
|
|
)
|
|
|
|
return (
|
|
HTTPMediaSource,
|
|
handle_transcode,
|
|
handle_transcode_hls_init,
|
|
handle_transcode_hls_playlist,
|
|
handle_transcode_hls_segment,
|
|
)
|
|
|
|
|
|
def sanitize_url(url: str) -> str:
|
|
"""
|
|
Sanitize URL to fix common encoding issues and handle base64 encoded URLs.
|
|
|
|
Args:
|
|
url (str): The URL to sanitize.
|
|
|
|
Returns:
|
|
str: The sanitized URL.
|
|
"""
|
|
original_url = url
|
|
|
|
# First, try to process potential base64 encoded URLs
|
|
url = process_potential_base64_url(url)
|
|
|
|
# Fix malformed URLs where https%22// should be https://
|
|
url = re.sub(r"https%22//", "https://", url)
|
|
url = re.sub(r"http%22//", "http://", url)
|
|
|
|
# Fix malformed URLs where https%3A%22// should be https://
|
|
url = re.sub(r"https%3A%22//", "https://", url)
|
|
url = re.sub(r"http%3A%22//", "http://", url)
|
|
|
|
# Fix malformed URLs where https:"// should be https:// (after partial decoding)
|
|
url = re.sub(r'https:"//', "https://", url)
|
|
url = re.sub(r'http:"//', "http://", url)
|
|
|
|
# Fix URLs where key_id and key parameters are incorrectly appended to the base URL
|
|
# This happens when the URL contains &key_id= and &key= which should be handled as proxy parameters
|
|
if "&key_id=" in url and "&key=" in url:
|
|
# Split the URL at the first occurrence of &key_id= to separate the base URL from the incorrectly appended parameters
|
|
base_url = url.split("&key_id=")[0]
|
|
logger.info(f"Removed incorrectly appended key parameters from URL: '{url}' -> '{base_url}'")
|
|
url = base_url
|
|
|
|
# Log if URL was changed
|
|
if url != original_url:
|
|
logger.info(f"URL sanitized: '{original_url}' -> '{url}'")
|
|
|
|
# Also try URL decoding to see what we get
|
|
try:
|
|
decoded_url = unquote(url)
|
|
if decoded_url != url:
|
|
logger.info(f"URL after decoding: '{decoded_url}'")
|
|
# If after decoding we still have malformed protocol, fix it
|
|
if ':"/' in decoded_url:
|
|
# Fix https:"// or http:"// patterns
|
|
fixed_decoded = re.sub(r'([a-z]+):"//', r"\1://", decoded_url)
|
|
logger.info(f"Fixed decoded URL: '{fixed_decoded}'")
|
|
return fixed_decoded
|
|
except Exception as e:
|
|
logger.warning(f"Error decoding URL '{url}': {e}")
|
|
|
|
return url
|
|
|
|
|
|
def extract_drm_params_from_url(url: str) -> tuple[str, str, str]:
|
|
"""
|
|
Extract DRM parameters (key_id and key) from a URL if they are incorrectly appended.
|
|
|
|
Args:
|
|
url (str): The URL that may contain appended DRM parameters.
|
|
|
|
Returns:
|
|
tuple: (clean_url, key_id, key) where clean_url has the parameters removed,
|
|
and key_id/key are the extracted values (or None if not found).
|
|
"""
|
|
key_id = None
|
|
key = None
|
|
clean_url = url
|
|
|
|
# Check if URL contains incorrectly appended key_id and key parameters
|
|
if "&key_id=" in url and "&key=" in url:
|
|
# Extract key_id
|
|
key_id_match = re.search(r"&key_id=([^&]+)", url)
|
|
if key_id_match:
|
|
key_id = key_id_match.group(1)
|
|
|
|
# Extract key
|
|
key_match = re.search(r"&key=([^&]+)", url)
|
|
if key_match:
|
|
key = key_match.group(1)
|
|
|
|
# Remove the parameters from the URL
|
|
clean_url = re.sub(r"&key_id=[^&]*", "", url)
|
|
clean_url = re.sub(r"&key=[^&]*", "", clean_url)
|
|
|
|
logger.info(f"Extracted DRM parameters from URL: key_id={key_id}, key={key}")
|
|
logger.info(f"Cleaned URL: '{url}' -> '{clean_url}'")
|
|
|
|
return clean_url, key_id, key
|
|
|
|
|
|
@proxy_router.head("/hls/manifest.m3u8")
|
|
@proxy_router.get("/hls/manifest.m3u8")
|
|
async def hls_manifest_proxy(
|
|
request: Request,
|
|
hls_params: Annotated[HLSManifestParams, Query()],
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
):
|
|
"""
|
|
Proxify HLS stream requests, fetching and processing the m3u8 playlist or streaming the content.
|
|
|
|
Args:
|
|
request (Request): The incoming HTTP request.
|
|
hls_params (HLSPlaylistParams): The parameters for the HLS stream request.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the processed m3u8 playlist or streamed content.
|
|
"""
|
|
# Sanitize destination URL to fix common encoding issues
|
|
hls_params.destination = sanitize_url(hls_params.destination)
|
|
|
|
# Check if destination contains Sportsonline pattern and extract stream directly
|
|
sportsonline_result = await check_and_extract_sportsonline_stream(request, hls_params.destination, proxy_headers)
|
|
if sportsonline_result:
|
|
# Update destination and headers with extracted stream data
|
|
hls_params.destination = sportsonline_result["destination_url"]
|
|
extracted_headers = sportsonline_result.get("request_headers", {})
|
|
proxy_headers.request.update(extracted_headers)
|
|
|
|
# Check if extractor wants key-only proxy
|
|
if sportsonline_result.get("mediaflow_endpoint") == "hls_key_proxy":
|
|
hls_params.key_only_proxy = True
|
|
|
|
# Also add headers to query params so they propagate to key/segment requests
|
|
query_dict = dict(request.query_params)
|
|
for header_name, header_value in extracted_headers.items():
|
|
# Add header with h_ prefix to query params
|
|
query_dict[f"h_{header_name}"] = header_value
|
|
# Update request query params
|
|
request._query_params = QueryParams(query_dict)
|
|
|
|
return await handle_hls_stream_proxy(request, hls_params, proxy_headers, hls_params.transformer)
|
|
|
|
|
|
@proxy_router.head("/hls/key_proxy/manifest.m3u8", name="hls_key_proxy")
|
|
@proxy_router.get("/hls/key_proxy/manifest.m3u8", name="hls_key_proxy")
|
|
async def hls_key_proxy(
|
|
request: Request,
|
|
hls_params: Annotated[HLSManifestParams, Query()],
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
):
|
|
"""
|
|
Proxify HLS stream requests, but only proxy the key URL, leaving segment URLs direct.
|
|
|
|
Args:
|
|
request (Request): The incoming HTTP request.
|
|
hls_params (HLSManifestParams): The parameters for the HLS stream request.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the processed m3u8 playlist.
|
|
"""
|
|
# Sanitize destination URL to fix common encoding issues
|
|
hls_params.destination = sanitize_url(hls_params.destination)
|
|
|
|
# Set the key_only_proxy flag to True
|
|
hls_params.key_only_proxy = True
|
|
|
|
return await handle_hls_stream_proxy(request, hls_params, proxy_headers, hls_params.transformer)
|
|
|
|
|
|
# Map file extensions to MIME types for HLS segments
|
|
HLS_SEGMENT_MIME_TYPES = {
|
|
"ts": "video/mp2t", # MPEG-TS (traditional HLS)
|
|
"m4s": "video/mp4", # fMP4 segment (modern HLS/CMAF)
|
|
"mp4": "video/mp4", # fMP4 segment (alternative extension)
|
|
"m4a": "audio/mp4", # Audio-only fMP4 segment
|
|
"m4v": "video/mp4", # Video fMP4 segment (alternative)
|
|
"aac": "audio/aac", # AAC audio segment
|
|
}
|
|
|
|
|
|
@proxy_router.get("/hls/segment.{ext}", name="hls_segment_proxy")
|
|
async def hls_segment_proxy(
|
|
request: Request,
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
ext: str,
|
|
segment_url: str = Query(..., description="URL of the HLS segment", alias="d"),
|
|
transformer: str = Query(None, description="Stream transformer ID for content manipulation"),
|
|
):
|
|
"""
|
|
Proxy HLS segments with pre-buffering support.
|
|
|
|
This endpoint supports multiple segment formats:
|
|
- /hls/segment.ts - MPEG-TS segments (traditional HLS)
|
|
- /hls/segment.m4s - fMP4 segments (modern HLS/CMAF)
|
|
- /hls/segment.mp4 - fMP4 segments (alternative)
|
|
- /hls/segment.m4a - Audio fMP4 segments
|
|
- /hls/segment.aac - AAC audio segments
|
|
|
|
Uses event-based coordination to prevent duplicate downloads between
|
|
player requests and background prebuffering.
|
|
|
|
Args:
|
|
request (Request): The incoming HTTP request.
|
|
ext (str): File extension determining the segment format.
|
|
segment_url (str): URL of the HLS segment to proxy.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
transformer (str, optional): Stream transformer ID for content manipulation.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the segment content.
|
|
"""
|
|
# Get MIME type for this extension
|
|
mime_type = HLS_SEGMENT_MIME_TYPES.get(ext.lower(), "application/octet-stream")
|
|
|
|
# Sanitize segment URL to fix common encoding issues
|
|
original_url = segment_url
|
|
segment_url = sanitize_url(segment_url)
|
|
|
|
logger.info(f"[hls_segment_proxy] Request for: {segment_url}")
|
|
if original_url != segment_url:
|
|
logger.warning(f"[hls_segment_proxy] URL was sanitized! Original: {original_url}")
|
|
|
|
# Extract headers for pre-buffering
|
|
headers = {}
|
|
for key, value in request.query_params.items():
|
|
if key.startswith("h_"):
|
|
headers[key[2:]] = value
|
|
|
|
if settings.enable_hls_prebuffer:
|
|
# Notify the prefetcher that this segment is needed (priority download)
|
|
# This ensures the player's segment is downloaded first, then prefetcher
|
|
# continues with sequential prefetch of remaining segments
|
|
await hls_prebuffer.request_segment(segment_url)
|
|
|
|
# Use cross-process coordination to get the segment
|
|
segment_data = await hls_prebuffer.get_or_download(segment_url, headers)
|
|
|
|
if segment_data:
|
|
logger.info(f"[hls_segment_proxy] Serving from prebuffer ({len(segment_data)} bytes): {segment_url}")
|
|
|
|
# Apply transformer if specified (e.g., PNG wrapper stripping)
|
|
if transformer:
|
|
segment_data = await apply_transformer_to_bytes(segment_data, transformer)
|
|
|
|
# Return cached/downloaded segment
|
|
base_headers = {
|
|
"content-type": mime_type,
|
|
"cache-control": "public, max-age=3600",
|
|
"access-control-allow-origin": "*",
|
|
}
|
|
response_headers = apply_header_manipulation(base_headers, proxy_headers)
|
|
return Response(content=segment_data, media_type=mime_type, headers=response_headers)
|
|
|
|
# get_or_download returned None (timeout or error) - fall through to direct fetch
|
|
logger.warning(f"[hls_segment_proxy] Prebuffer timeout, using direct fetch: {segment_url}")
|
|
|
|
# Fallback to direct streaming.
|
|
# Override the response Content-Type so that CDN-served MPEG-TS segments
|
|
# are not interpreted as a non-video format.
|
|
if mime_type != "application/octet-stream":
|
|
proxy_headers.response["content-type"] = mime_type
|
|
return await handle_stream_request("GET", segment_url, proxy_headers, transformer)
|
|
|
|
|
|
# =============================================================================
|
|
# HLS Transcode endpoints (VOD playlist + init segment + media segments)
|
|
# =============================================================================
|
|
|
|
|
|
@proxy_router.head("/transcode/playlist.m3u8")
|
|
@proxy_router.get("/transcode/playlist.m3u8")
|
|
async def transcode_hls_playlist(
|
|
request: Request,
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
destination: str = Query(..., description="The URL of the source media.", alias="d"),
|
|
):
|
|
"""
|
|
Generate an HLS VOD M3U8 playlist for on-the-fly transcoded content.
|
|
|
|
Probes the source file's keyframe index and generates a playlist where
|
|
each segment corresponds to one or more keyframe intervals. The playlist
|
|
references the init segment and media segment endpoints below.
|
|
|
|
The generated playlist uses ``#EXT-X-VERSION:7`` with fMP4 (CMAF)
|
|
segments for universal browser and player compatibility.
|
|
|
|
Args:
|
|
request: The incoming HTTP request.
|
|
proxy_headers: Headers to forward to the source.
|
|
destination: URL of the source media file.
|
|
"""
|
|
if not settings.enable_transcode:
|
|
raise HTTPException(status_code=503, detail="Transcoding support is disabled")
|
|
HTTPMediaSource, _, _, handle_transcode_hls_playlist, _ = _load_transcode_components()
|
|
destination = sanitize_url(destination)
|
|
source = HTTPMediaSource(url=destination, headers=dict(proxy_headers.request))
|
|
await source.resolve_file_size()
|
|
|
|
# Build URLs for init and segment endpoints that preserve query params
|
|
# (api_password, headers, etc.) from the current request.
|
|
base_params = _build_hls_query_params(request, destination)
|
|
|
|
init_url = f"/proxy/transcode/init.mp4?{base_params}"
|
|
segment_url_template = (
|
|
f"/proxy/transcode/segment.m4s?{base_params}&seg={{seg}}&start_ms={{start_ms}}&end_ms={{end_ms}}"
|
|
)
|
|
|
|
return await handle_transcode_hls_playlist(
|
|
request,
|
|
source,
|
|
init_url=init_url,
|
|
segment_url_template=segment_url_template,
|
|
)
|
|
|
|
|
|
@proxy_router.head("/transcode/init.mp4")
|
|
@proxy_router.get("/transcode/init.mp4")
|
|
async def transcode_hls_init(
|
|
request: Request,
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
destination: str = Query(..., description="The URL of the source media.", alias="d"),
|
|
):
|
|
"""
|
|
Serve the fMP4 init segment (ftyp + moov) for HLS transcode playback.
|
|
|
|
The init segment is built from probed track metadata without running
|
|
the full transcode pipeline.
|
|
|
|
Args:
|
|
request: The incoming HTTP request.
|
|
proxy_headers: Headers to forward to the source.
|
|
destination: URL of the source media file.
|
|
"""
|
|
if not settings.enable_transcode:
|
|
raise HTTPException(status_code=503, detail="Transcoding support is disabled")
|
|
HTTPMediaSource, _, handle_transcode_hls_init, _, _ = _load_transcode_components()
|
|
destination = sanitize_url(destination)
|
|
source = HTTPMediaSource(url=destination, headers=dict(proxy_headers.request))
|
|
await source.resolve_file_size()
|
|
|
|
return await handle_transcode_hls_init(request, source)
|
|
|
|
|
|
@proxy_router.get("/transcode/segment.m4s")
|
|
async def transcode_hls_segment(
|
|
request: Request,
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
destination: str = Query(..., description="The URL of the source media.", alias="d"),
|
|
start_ms: float = Query(..., description="Segment start time in milliseconds."),
|
|
end_ms: float = Query(..., description="Segment end time in milliseconds."),
|
|
seg: int | None = Query(None, description="Segment number (informational, for logging)."),
|
|
):
|
|
"""
|
|
Serve a single HLS fMP4 media segment (moof + mdat).
|
|
|
|
Each segment corresponds to a merged keyframe interval in the source
|
|
file. The time range is self-describing (from the playlist URL) so
|
|
no cue-point re-derivation is needed.
|
|
|
|
Args:
|
|
request: The incoming HTTP request.
|
|
proxy_headers: Headers to forward to the source.
|
|
destination: URL of the source media file.
|
|
start_ms: Segment start time in milliseconds.
|
|
end_ms: Segment end time in milliseconds.
|
|
"""
|
|
if not settings.enable_transcode:
|
|
raise HTTPException(status_code=503, detail="Transcoding support is disabled")
|
|
HTTPMediaSource, _, _, _, handle_transcode_hls_segment = _load_transcode_components()
|
|
destination = sanitize_url(destination)
|
|
source = HTTPMediaSource(url=destination, headers=dict(proxy_headers.request))
|
|
await source.resolve_file_size()
|
|
|
|
return await handle_transcode_hls_segment(
|
|
request, source, start_time_ms=start_ms, end_time_ms=end_ms, segment_number=seg
|
|
)
|
|
|
|
|
|
def _build_hls_query_params(request: Request, destination: str) -> str:
|
|
"""
|
|
Build query string for HLS sub-requests, preserving auth and header params.
|
|
|
|
Copies ``api_password``, header manipulation params (``h_*``), and the
|
|
destination URL from the original request.
|
|
"""
|
|
params = [f"d={quote(destination, safe='')}"]
|
|
original = request.query_params
|
|
if "api_password" in original:
|
|
params.append(f"api_password={quote(original['api_password'], safe='')}")
|
|
# Preserve header overrides (h_referer, h_origin, etc.)
|
|
for key in original:
|
|
if key.startswith("h_"):
|
|
params.append(f"{key}={quote(original[key], safe='')}")
|
|
return "&".join(params)
|
|
|
|
|
|
MEDIAFLOW_IP_PLACEHOLDER = "{mediaflow_ip}"
|
|
_IP_DETECT_URLS = ["https://api.ipify.org", "https://checkip.amazonaws.com"]
|
|
_cached_public_ip: str | None = None
|
|
_public_ip_lock: asyncio.Lock | None = None
|
|
|
|
|
|
async def _resolve_public_ip() -> str | None:
|
|
"""Return MediaFlow's public IP: configured value, cached detection, or None."""
|
|
global _cached_public_ip, _public_ip_lock
|
|
|
|
if settings.public_ip:
|
|
return settings.public_ip
|
|
if _cached_public_ip:
|
|
return _cached_public_ip
|
|
|
|
if _public_ip_lock is None:
|
|
_public_ip_lock = asyncio.Lock()
|
|
|
|
async with _public_ip_lock:
|
|
if _cached_public_ip:
|
|
return _cached_public_ip
|
|
for url in _IP_DETECT_URLS:
|
|
try:
|
|
async with aiohttp.ClientSession() as sess:
|
|
async with sess.get(url, timeout=ClientTimeout(total=5)) as resp:
|
|
ip = (await resp.text()).strip()
|
|
if ip:
|
|
_cached_public_ip = ip
|
|
return ip
|
|
except Exception:
|
|
continue
|
|
return None
|
|
|
|
|
|
_IP_DISCLOSURE_HEADERS = frozenset(
|
|
{
|
|
"x-forwarded-for",
|
|
"x-real-ip",
|
|
"x-client-ip",
|
|
"true-client-ip",
|
|
"forwarded",
|
|
"cf-connecting-ip",
|
|
"x-original-forwarded-for",
|
|
"x-cluster-client-ip",
|
|
}
|
|
)
|
|
|
|
_HOP_BY_HOP_HEADERS = frozenset(
|
|
{
|
|
"connection",
|
|
"keep-alive",
|
|
"proxy-authenticate",
|
|
"proxy-authorization",
|
|
"te",
|
|
"trailers",
|
|
"transfer-encoding",
|
|
"upgrade",
|
|
}
|
|
)
|
|
|
|
# Headers that callers must not inject via h_* params — they enable host-header
|
|
# injection, HTTP request smuggling, or break the session's own framing logic.
|
|
_BLOCKED_REQUEST_HEADERS = frozenset(
|
|
{
|
|
"host",
|
|
"content-length",
|
|
"transfer-encoding",
|
|
"content-encoding",
|
|
}
|
|
)
|
|
|
|
|
|
def _check_forward_destination(destination: str) -> None:
|
|
"""SSRF guard and allowlist/denylist check for /proxy/forward."""
|
|
parsed = urlparse(destination)
|
|
|
|
# Only allow http(s) — blocks file://, ftp://, gopher://, data:, javascript:, etc.
|
|
scheme = (parsed.scheme or "").lower()
|
|
if scheme not in ("http", "https"):
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Invalid URL scheme '{scheme}'. Only http and https are allowed.",
|
|
)
|
|
|
|
hostname = (parsed.hostname or "").lower()
|
|
|
|
if not hostname:
|
|
raise HTTPException(status_code=400, detail="Invalid destination URL: no hostname")
|
|
|
|
# Allowlist check (if configured)
|
|
allowed = settings.forward_allowed_hosts
|
|
if allowed and hostname not in {h.lower() for h in allowed}:
|
|
raise HTTPException(status_code=403, detail=f"Host '{hostname}' is not in forward_allowed_hosts")
|
|
|
|
# Explicit denylist
|
|
denied = {h.lower() for h in settings.forward_denied_hosts}
|
|
if hostname in denied:
|
|
raise HTTPException(status_code=403, detail=f"Host '{hostname}' is denied")
|
|
|
|
# Always block loopback literals
|
|
if hostname in ("localhost", "ip6-localhost", "ip6-loopback"):
|
|
raise HTTPException(status_code=403, detail="Forwarding to localhost is not allowed")
|
|
|
|
# Block private/loopback/link-local IPs given as literals
|
|
try:
|
|
addr = ipaddress.ip_address(hostname)
|
|
if addr.is_private or addr.is_loopback or addr.is_link_local or addr.is_unspecified:
|
|
raise HTTPException(status_code=403, detail="Forwarding to private/loopback addresses is not allowed")
|
|
except ValueError:
|
|
pass # Not a numeric IP — hostname-based SSRF is the caller's responsibility
|
|
|
|
|
|
@proxy_router.api_route(
|
|
"/forward",
|
|
methods=["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
|
|
)
|
|
async def proxy_forward_endpoint(
|
|
request: Request,
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
destination: str = Query(..., description="The destination URL to forward to.", alias="d"),
|
|
):
|
|
"""
|
|
Generic transparent HTTP forwarding endpoint.
|
|
|
|
Forwards any HTTP method (including POST with body) to the given destination URL
|
|
using MediaFlow's outbound IP. Useful for IP-bound API calls (e.g. debrid service
|
|
APIs, extractor POST requests) where the request must appear to originate from
|
|
MediaFlow rather than the addon server.
|
|
|
|
Pass outbound headers via ``h_<name>=<value>`` query params. The upstream response
|
|
(status code, headers, body) is returned verbatim. IP-disclosure headers are
|
|
stripped before forwarding so the caller's IP is not leaked.
|
|
"""
|
|
destination = sanitize_url(destination)
|
|
_check_forward_destination(destination)
|
|
|
|
# Strip IP-disclosure headers — the whole point is hiding the origin IP
|
|
for h in _IP_DISCLOSURE_HEADERS:
|
|
proxy_headers.request.pop(h, None)
|
|
|
|
# Strip headers that could enable host-header injection or HTTP smuggling
|
|
for h in _BLOCKED_REQUEST_HEADERS:
|
|
proxy_headers.request.pop(h, None)
|
|
|
|
body = await request.body()
|
|
if len(body) > settings.forward_max_request_body_bytes:
|
|
raise HTTPException(status_code=413, detail="Request body too large")
|
|
max_response_bytes = settings.forward_max_response_body_bytes
|
|
|
|
# Substitute {mediaflow_ip} placeholder with MediaFlow's actual public IP so
|
|
# debrid services receive a consistent ip= parameter that matches the TCP source.
|
|
if MEDIAFLOW_IP_PLACEHOLDER in destination or MEDIAFLOW_IP_PLACEHOLDER.encode() in body:
|
|
public_ip = await _resolve_public_ip()
|
|
if public_ip:
|
|
destination = destination.replace(MEDIAFLOW_IP_PLACEHOLDER, public_ip)
|
|
body = body.replace(MEDIAFLOW_IP_PLACEHOLDER.encode(), public_ip.encode())
|
|
|
|
async with create_aiohttp_session(destination) as (session, proxy_url):
|
|
try:
|
|
async with session.request(
|
|
method=request.method,
|
|
url=destination,
|
|
headers=proxy_headers.request,
|
|
data=body if body else None,
|
|
proxy=proxy_url,
|
|
timeout=ClientTimeout(total=settings.transport_config.timeout),
|
|
allow_redirects=True,
|
|
) as upstream_resp:
|
|
resp_body = await upstream_resp.content.read(max_response_bytes + 1)
|
|
if len(resp_body) > max_response_bytes:
|
|
raise HTTPException(status_code=502, detail="Upstream response too large")
|
|
|
|
resp_headers = {k: v for k, v in upstream_resp.headers.items() if k.lower() not in _HOP_BY_HOP_HEADERS}
|
|
resp_headers.update(proxy_headers.response)
|
|
|
|
return Response(
|
|
content=resp_body,
|
|
status_code=upstream_resp.status,
|
|
headers=resp_headers,
|
|
)
|
|
except aiohttp.ClientResponseError as e:
|
|
raise HTTPException(status_code=e.status, detail=f"Upstream error: {e.message}")
|
|
except asyncio.TimeoutError:
|
|
raise HTTPException(status_code=504, detail="Upstream timeout")
|
|
except aiohttp.ClientError as e:
|
|
raise HTTPException(status_code=502, detail=f"Upstream connection error: {e}")
|
|
|
|
|
|
@proxy_router.get("/ip")
|
|
async def get_public_ip_endpoint():
|
|
"""Return MediaFlow's public IP address."""
|
|
ip = await _resolve_public_ip()
|
|
if ip is None:
|
|
raise HTTPException(status_code=503, detail="Could not determine public IP")
|
|
return {"ip": ip}
|
|
|
|
|
|
@proxy_router.head("/stream")
|
|
@proxy_router.get("/stream")
|
|
@proxy_router.head("/stream/{filename:path}")
|
|
@proxy_router.get("/stream/{filename:path}")
|
|
async def proxy_stream_endpoint(
|
|
request: Request,
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
destination: str = Query(..., description="The URL of the stream.", alias="d"),
|
|
filename: str | None = None,
|
|
transformer: str = Query(None, description="Stream transformer ID for content manipulation"),
|
|
ratelimit: str = Query(
|
|
None,
|
|
description="Rate limit handler ID for host-specific rate limiting (e.g., 'vidoza', 'aggressive'). "
|
|
"If not specified, auto-detects based on destination URL hostname. "
|
|
"Set to 'none' to explicitly disable rate limiting.",
|
|
),
|
|
transcode: bool = Query(
|
|
False, description="Transcode to browser-compatible fMP4 (re-encode video/audio as needed)"
|
|
),
|
|
start: float | None = Query(None, description="Seek start time in seconds (used with transcode=true)"),
|
|
):
|
|
"""
|
|
Proxify stream requests to the given video URL.
|
|
|
|
This is a general-purpose stream proxy endpoint. For HLS segments with prebuffer
|
|
support, use the dedicated /hls/segment.ts endpoint instead.
|
|
|
|
When transcode=true, the media is transcoded on-the-fly to browser-compatible
|
|
fMP4 (H.264 video + AAC audio). Video is re-encoded only if the source codec
|
|
is not browser-compatible (e.g. H.265, MPEG-2). Audio is transcoded to AAC
|
|
when needed (e.g. EAC3, AC3, DTS). GPU acceleration is used when available.
|
|
|
|
Rate limiting can be controlled via the `ratelimit` parameter:
|
|
- Not specified: Auto-detects based on destination URL (e.g., Vidoza is auto-detected)
|
|
- "vidoza": Explicitly enable Vidoza rate limiting (5s cooldown between connections)
|
|
- "aggressive": Generic aggressive rate limiting (3s cooldown)
|
|
- "none": Explicitly disable all rate limiting
|
|
|
|
Args:
|
|
request (Request): The incoming HTTP request.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
destination (str): The URL of the stream to be proxied.
|
|
filename (str | None): The filename to be used in the response headers.
|
|
transformer (str, optional): Stream transformer ID for content manipulation.
|
|
ratelimit (str, optional): Rate limit handler ID for host-specific rate limiting.
|
|
transcode (bool): Transcode to browser-compatible format.
|
|
start (float, optional): Seek start time in seconds (transcode mode only).
|
|
|
|
Returns:
|
|
Response: The HTTP response with the streamed content.
|
|
"""
|
|
# Log incoming request details for debugging seek issues
|
|
range_header = proxy_headers.request.get("range", "not set")
|
|
logger.info(
|
|
f"[proxy_stream] Request received - filename: {filename}, range: {range_header}, "
|
|
f"method: {request.method}, transcode: {transcode}"
|
|
)
|
|
|
|
# Sanitize destination URL to fix common encoding issues
|
|
destination = sanitize_url(destination)
|
|
|
|
# Handle transcode mode — transcode uses time-based seeking, not byte ranges
|
|
if transcode:
|
|
if not settings.enable_transcode:
|
|
raise HTTPException(status_code=503, detail="Transcoding support is disabled")
|
|
HTTPMediaSource, handle_transcode, _, _, _ = _load_transcode_components()
|
|
transcode_headers = dict(proxy_headers.request)
|
|
transcode_headers.pop("range", None)
|
|
transcode_headers.pop("if-range", None)
|
|
source = HTTPMediaSource(url=destination, headers=transcode_headers)
|
|
await source.resolve_file_size()
|
|
return await handle_transcode(request, source, start_time=start)
|
|
|
|
if proxy_headers.request.get("range", "").strip() == "":
|
|
proxy_headers.request.pop("range", None)
|
|
|
|
if proxy_headers.request.get("if-range", "").strip() == "":
|
|
proxy_headers.request.pop("if-range", None)
|
|
|
|
if "range" not in proxy_headers.request:
|
|
proxy_headers.request["range"] = "bytes=0-"
|
|
# Mark that this range was auto-added (not from client)
|
|
# This is used in handlers.py to decide whether to convert 206->200
|
|
proxy_headers.auto_added_range = True
|
|
|
|
if filename:
|
|
# If a filename is provided (not a segment), set it in the headers using RFC 6266 format
|
|
try:
|
|
# Try to encode with latin-1 first (simple case)
|
|
filename.encode("latin-1")
|
|
content_disposition = f'attachment; filename="{filename}"'
|
|
except UnicodeEncodeError:
|
|
# For filenames with non-latin-1 characters, use RFC 6266 format with UTF-8
|
|
encoded_filename = quote(filename.encode("utf-8"))
|
|
content_disposition = f"attachment; filename*=UTF-8''{encoded_filename}"
|
|
|
|
proxy_headers.response.update({"content-disposition": content_disposition})
|
|
|
|
# Handle "none" as explicit disable
|
|
rate_limit_handler_id = None if ratelimit == "none" else ratelimit
|
|
|
|
return await proxy_stream(request.method, destination, proxy_headers, transformer, rate_limit_handler_id)
|
|
|
|
|
|
@proxy_router.head("/mpd/manifest.m3u8")
|
|
@proxy_router.get("/mpd/manifest.m3u8")
|
|
async def mpd_manifest_proxy(
|
|
request: Request,
|
|
manifest_params: Annotated[MPDManifestParams, Query()],
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
):
|
|
"""
|
|
Retrieves and processes the MPD manifest, converting it to an HLS manifest.
|
|
|
|
Args:
|
|
request (Request): The incoming HTTP request.
|
|
manifest_params (MPDManifestParams): The parameters for the manifest request.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the HLS manifest.
|
|
"""
|
|
# Extract DRM parameters from destination URL if they are incorrectly appended
|
|
clean_url, extracted_key_id, extracted_key = extract_drm_params_from_url(manifest_params.destination)
|
|
|
|
# Update the destination with the cleaned URL
|
|
manifest_params.destination = clean_url
|
|
|
|
# Use extracted parameters if they exist and the manifest params don't already have them
|
|
if extracted_key_id and not manifest_params.key_id:
|
|
manifest_params.key_id = extracted_key_id
|
|
if extracted_key and not manifest_params.key:
|
|
manifest_params.key = extracted_key
|
|
|
|
# Sanitize destination URL to fix common encoding issues
|
|
manifest_params.destination = sanitize_url(manifest_params.destination)
|
|
|
|
return await get_manifest(request, manifest_params, proxy_headers)
|
|
|
|
|
|
@proxy_router.head("/mpd/playlist.m3u8")
|
|
@proxy_router.get("/mpd/playlist.m3u8")
|
|
async def playlist_endpoint(
|
|
request: Request,
|
|
playlist_params: Annotated[MPDPlaylistParams, Query()],
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
):
|
|
"""
|
|
Retrieves and processes the MPD manifest, converting it to an HLS playlist for a specific profile.
|
|
|
|
Args:
|
|
request (Request): The incoming HTTP request.
|
|
playlist_params (MPDPlaylistParams): The parameters for the playlist request.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the HLS playlist.
|
|
"""
|
|
# Extract DRM parameters from destination URL if they are incorrectly appended
|
|
clean_url, extracted_key_id, extracted_key = extract_drm_params_from_url(playlist_params.destination)
|
|
|
|
# Update the destination with the cleaned URL
|
|
playlist_params.destination = clean_url
|
|
|
|
# Use extracted parameters if they exist and the playlist params don't already have them
|
|
if extracted_key_id and not playlist_params.key_id:
|
|
playlist_params.key_id = extracted_key_id
|
|
if extracted_key and not playlist_params.key:
|
|
playlist_params.key = extracted_key
|
|
|
|
# Sanitize destination URL to fix common encoding issues
|
|
playlist_params.destination = sanitize_url(playlist_params.destination)
|
|
|
|
return await get_playlist(request, playlist_params, proxy_headers)
|
|
|
|
|
|
@proxy_router.get("/mpd/segment.mp4")
|
|
async def segment_endpoint(
|
|
segment_params: Annotated[MPDSegmentParams, Query()],
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
):
|
|
"""
|
|
Retrieves and processes a media segment, decrypting it if necessary.
|
|
|
|
This endpoint serves fMP4 segments without TS remuxing. The playlist generator
|
|
already selects /segment.mp4 vs /segment.ts based on the resolved remux mode,
|
|
so this endpoint explicitly disables remuxing regardless of global settings.
|
|
|
|
Args:
|
|
segment_params (MPDSegmentParams): The parameters for the segment request.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the processed segment.
|
|
"""
|
|
return await get_segment(segment_params, proxy_headers, force_remux_ts=False)
|
|
|
|
|
|
@proxy_router.get("/mpd/segment.ts")
|
|
async def segment_ts_endpoint(
|
|
segment_params: Annotated[MPDSegmentParams, Query()],
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
):
|
|
"""
|
|
Retrieves and processes a media segment, remuxing fMP4 to MPEG-TS.
|
|
|
|
This endpoint is used for HLS playlists when remux_to_ts is enabled.
|
|
Unlike /mpd/segment.mp4, this forces TS remuxing regardless of global settings.
|
|
|
|
Args:
|
|
segment_params (MPDSegmentParams): The parameters for the segment request.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the MPEG-TS segment.
|
|
"""
|
|
return await get_segment(segment_params, proxy_headers, force_remux_ts=True)
|
|
|
|
|
|
@proxy_router.get("/mpd/init.mp4")
|
|
async def init_endpoint(
|
|
init_params: Annotated[MPDInitParams, Query()],
|
|
proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)],
|
|
):
|
|
"""
|
|
Retrieves and processes an initialization segment for use with EXT-X-MAP.
|
|
|
|
Args:
|
|
init_params (MPDInitParams): The parameters for the init segment request.
|
|
proxy_headers (ProxyRequestHeaders): The headers to include in the request.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the processed init segment.
|
|
"""
|
|
return await get_init_segment(init_params, proxy_headers)
|
|
|
|
|
|
@proxy_router.get("/ip")
|
|
async def get_mediaflow_proxy_public_ip():
|
|
"""
|
|
Retrieves the public IP address of the MediaFlow proxy server.
|
|
|
|
Returns:
|
|
Response: The HTTP response with the public IP address in the form of a JSON object. {"ip": "xxx.xxx.xxx.xxx"}
|
|
"""
|
|
return await get_public_ip()
|