Home/UnHided
2
0
Fork 0
mirror of https://github.com/UrloMythus/UnHided.git synced 2026-04-11 11:50:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
UrloMythus
2026-02-19 20:15:03 +01:00
parent 7785e8c604
commit cfc6bbabc9
181 changed files with 32141 additions and 4629 deletions
Download Patch File Download Diff File Expand all files Collapse all files

804
mediaflow_proxy/extractors/dlhd.py
View File

@@ -1,133 +1,345 @@
import hashlib
import hmac
import re
import base64
import time
import logging
from typing import Any, Dict, Optional, List
from urllib.parse import urlparse, quote_plus, urljoin
from typing import Any, Dict, Optional
from urllib.parse import urlparse
import aiohttp
import httpx
from mediaflow_proxy.extractors.base import BaseExtractor, ExtractorError
from mediaflow_proxy.extractors.base import BaseExtractor, ExtractorError, HttpResponse
from mediaflow_proxy.utils.http_client import create_aiohttp_session
from mediaflow_proxy.configs import settings
logger = logging.getLogger(__name__)
# Silenzia l'errore ConnectionResetError su Windows
logging.getLogger('asyncio').setLevel(logging.CRITICAL)
logging.getLogger("asyncio").setLevel(logging.CRITICAL)
# Default fingerprint parameters
DEFAULT_DLHD_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0"
DEFAULT_DLHD_SCREEN_RESOLUTION = "1920x1080"
DEFAULT_DLHD_TIMEZONE = "UTC"
DEFAULT_DLHD_LANGUAGE = "en"
def compute_fingerprint(
user_agent: str = DEFAULT_DLHD_USER_AGENT,
screen_resolution: str = DEFAULT_DLHD_SCREEN_RESOLUTION,
timezone: str = DEFAULT_DLHD_TIMEZONE,
language: str = DEFAULT_DLHD_LANGUAGE,
) -> str:
"""
Compute the X-Fingerprint header value.
Algorithm:
fingerprint = SHA256(useragent + screen_resolution + timezone + language).hex()[:16]
Args:
user_agent: The user agent string
screen_resolution: The screen resolution (e.g., "1920x1080")
timezone: The timezone (e.g., "UTC")
language: The language code (e.g., "en")
Returns:
The 16-character fingerprint
"""
combined = f"{user_agent}{screen_resolution}{timezone}{language}"
return hashlib.sha256(combined.encode("utf-8")).hexdigest()[:16]
def compute_key_path(resource: str, number: str, timestamp: int, fingerprint: str, secret_key: str) -> str:
"""
Compute the X-Key-Path header value.
Algorithm:
key_path = HMAC-SHA256("resource|number|timestamp|fingerprint", secret_key).hex()[:16]
Args:
resource: The resource from the key URL
number: The number from the key URL
timestamp: The Unix timestamp
fingerprint: The fingerprint value
secret_key: The HMAC secret key (channel_salt)
Returns:
The 16-character key path
"""
combined = f"{resource}|{number}|{timestamp}|{fingerprint}"
hmac_hash = hmac.new(secret_key.encode("utf-8"), combined.encode("utf-8"), hashlib.sha256).hexdigest()
return hmac_hash[:16]
def compute_key_headers(key_url: str, secret_key: str) -> tuple[int, int, str, str] | None:
"""
Compute X-Key-Timestamp, X-Key-Nonce, X-Key-Path, and X-Fingerprint for a /key/ URL.
Algorithm:
1. Extract resource and number from URL pattern /key/{resource}/{number}
2. ts = Unix timestamp in seconds
3. hmac_hash = HMAC-SHA256(resource, secret_key).hex()
4. nonce = proof-of-work: find i where MD5(hmac+resource+number+ts+i)[:4] < 0x1000
5. fingerprint = compute_fingerprint()
6. key_path = HMAC-SHA256("resource|number|ts|fingerprint", secret_key).hex()[:16]
Args:
key_url: The key URL containing /key/{resource}/{number}
secret_key: The HMAC secret key (channel_salt)
Returns:
Tuple of (timestamp, nonce, key_path, fingerprint) or None if URL doesn't match pattern
"""
# Extract resource and number from URL
pattern = r"/key/([^/]+)/(\d+)"
match = re.search(pattern, key_url)
if not match:
return None
resource = match.group(1)
number = match.group(2)
ts = int(time.time())
# Compute HMAC-SHA256
hmac_hash = hmac.new(secret_key.encode("utf-8"), resource.encode("utf-8"), hashlib.sha256).hexdigest()
# Proof-of-work loop
nonce = 0
for i in range(100000):
combined = f"{hmac_hash}{resource}{number}{ts}{i}"
md5_hash = hashlib.md5(combined.encode("utf-8")).hexdigest()
prefix_value = int(md5_hash[:4], 16)
if prefix_value < 0x1000: # < 4096
nonce = i
break
fingerprint = compute_fingerprint()
key_path = compute_key_path(resource, number, ts, fingerprint, secret_key)
return ts, nonce, key_path, fingerprint
class DLHDExtractor(BaseExtractor):
"""DLHD (DaddyLive) URL extractor for M3U8 streams.
Notes:
- Multi-domain support for daddylive.sx / dlhd.dad
- Robust extraction of auth parameters and server lookup
- Uses retries/timeouts via BaseExtractor where possible
- Multi-iframe fallback for resilience
Supports the new authentication flow with:
- EPlayerAuth extraction (auth_token, channel_key, channel_salt)
- Server lookup for dynamic server selection
- Dynamic key header computation for AES-128 encrypted streams
"""
def __init__(self, request_headers: dict):
super().__init__(request_headers)
self.mediaflow_endpoint = "hls_manifest_proxy"
self.mediaflow_endpoint = "hls_key_proxy"
self._iframe_context: Optional[str] = None
self._flaresolverr_cookies: Optional[str] = None
self._flaresolverr_user_agent: Optional[str] = None
async def _fetch_via_flaresolverr(self, url: str) -> HttpResponse:
"""Fetch a URL using FlareSolverr to bypass Cloudflare protection."""
if not settings.flaresolverr_url:
raise ExtractorError("FlareSolverr URL not configured. Set FLARESOLVERR_URL in environment.")
flaresolverr_endpoint = f"{settings.flaresolverr_url.rstrip('/')}/v1"
payload = {
"cmd": "request.get",
"url": url,
"maxTimeout": settings.flaresolverr_timeout * 1000,
}
async def _make_request(self, url: str, method: str = "GET", headers: Optional[Dict] = None, **kwargs) -> Any:
"""Override to disable SSL verification for this extractor and use fetch_with_retry if available."""
from mediaflow_proxy.utils.http_utils import create_httpx_client, fetch_with_retry
logger.info(f"Using FlareSolverr to fetch: {url}")
async with aiohttp.ClientSession() as session:
async with session.post(
flaresolverr_endpoint,
json=payload,
timeout=aiohttp.ClientTimeout(total=settings.flaresolverr_timeout + 10),
) as response:
if response.status != 200:
raise ExtractorError(f"FlareSolverr returned status {response.status}")
data = await response.json()
if data.get("status") != "ok":
raise ExtractorError(f"FlareSolverr failed: {data.get('message', 'Unknown error')}")
solution = data.get("solution", {})
html_content = solution.get("response", "")
final_url = solution.get("url", url)
status = solution.get("status", 200)
# Store cookies and user-agent for subsequent requests
cookies = solution.get("cookies", [])
if cookies:
cookie_str = "; ".join([f"{c['name']}={c['value']}" for c in cookies])
self._flaresolverr_cookies = cookie_str
logger.info(f"FlareSolverr provided {len(cookies)} cookies")
user_agent = solution.get("userAgent")
if user_agent:
self._flaresolverr_user_agent = user_agent
logger.info(f"FlareSolverr user-agent: {user_agent}")
logger.info(f"FlareSolverr successfully bypassed Cloudflare for: {url}")
return HttpResponse(
status=status,
headers={},
text=html_content,
content=html_content.encode("utf-8", errors="replace"),
url=final_url,
)
async def _make_request(
self, url: str, method: str = "GET", headers: Optional[Dict] = None, use_flaresolverr: bool = False, **kwargs
) -> HttpResponse:
"""Override to disable SSL verification and optionally use FlareSolverr."""
# Use FlareSolverr for Cloudflare-protected pages
if use_flaresolverr and settings.flaresolverr_url:
return await self._fetch_via_flaresolverr(url)
timeout = kwargs.pop("timeout", 15)
retries = kwargs.pop("retries", 3)
backoff_factor = kwargs.pop("backoff_factor", 0.5)
kwargs.pop("retries", 3) # consumed but not used directly
kwargs.pop("backoff_factor", 0.5) # consumed but not used directly
# Merge headers
request_headers = self.base_headers.copy()
if headers:
request_headers.update(headers)
async with create_httpx_client(verify=False, timeout=httpx.Timeout(timeout)) as client:
try:
return await fetch_with_retry(client, method, url, headers or {}, timeout=timeout)
except Exception:
logger.debug("fetch_with_retry failed or unavailable; falling back to direct request for %s", url)
response = await client.request(method, url, headers=headers or {}, timeout=timeout)
response.raise_for_status()
return response
# Add FlareSolverr cookies if available
if self._flaresolverr_cookies:
existing_cookies = request_headers.get("Cookie", "")
if existing_cookies:
request_headers["Cookie"] = f"{existing_cookies}; {self._flaresolverr_cookies}"
else:
request_headers["Cookie"] = self._flaresolverr_cookies
# Use FlareSolverr user-agent if available
if self._flaresolverr_user_agent:
request_headers["User-Agent"] = self._flaresolverr_user_agent
async def _extract_lovecdn_stream(self, iframe_url: str, iframe_content: str, headers: dict) -> Dict[str, Any]:
# Use create_aiohttp_session with verify=False for SSL bypass
async with create_aiohttp_session(url, timeout=timeout, verify=False) as (session, proxy_url):
async with session.request(method, url, headers=request_headers, proxy=proxy_url, **kwargs) as response:
content = await response.read()
final_url = str(response.url)
status = response.status
resp_headers = dict(response.headers)
if status >= 400:
raise ExtractorError(f"HTTP error {status} while requesting {url}")
return HttpResponse(
status=status,
headers=resp_headers,
text=content.decode("utf-8", errors="replace"),
content=content,
url=final_url,
)
async def _extract_session_data(self, iframe_url: str, main_url: str) -> dict | None:
"""
Estrattore alternativo per iframe lovecdn.ru che usa un formato diverso.
Fetch the iframe URL and extract auth_token, channel_key, and channel_salt.
Args:
iframe_url: The iframe URL to fetch
main_url: The main site domain for Referer header
Returns:
Dict with auth_token, channel_key, channel_salt, or None if not found
"""
headers = {
"User-Agent": self._flaresolverr_user_agent or DEFAULT_DLHD_USER_AGENT,
"Referer": f"https://{main_url}/",
}
try:
# Cerca pattern di stream URL diretto
m3u8_patterns = [
r'["\']([^"\']*\.m3u8[^"\']*)["\']',
r'source[:\s]+["\']([^"\']+)["\']',
r'file[:\s]+["\']([^"\']+\.m3u8[^"\']*)["\']',
r'hlsManifestUrl[:\s]*["\']([^"\']+)["\']',
]
stream_url = None
for pattern in m3u8_patterns:
matches = re.findall(pattern, iframe_content)
for match in matches:
if '.m3u8' in match and match.startswith('http'):
stream_url = match
logger.info(f"Found direct m3u8 URL: {stream_url}")
break
if stream_url:
break
# Pattern 2: Cerca costruzione dinamica URL
if not stream_url:
channel_match = re.search(r'(?:stream|channel)["\s:=]+["\']([^"\']+)["\']', iframe_content)
server_match = re.search(r'(?:server|domain|host)["\s:=]+["\']([^"\']+)["\']', iframe_content)
if channel_match:
channel_name = channel_match.group(1)
server = server_match.group(1) if server_match else 'newkso.ru'
stream_url = f"https://{server}/{channel_name}/mono.m3u8"
logger.info(f"Constructed stream URL: {stream_url}")
if not stream_url:
# Fallback: cerca qualsiasi URL che sembri uno stream
url_pattern = r'https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*'
matches = re.findall(url_pattern, iframe_content)
if matches:
stream_url = matches[0]
logger.info(f"Found fallback stream URL: {stream_url}")
if not stream_url:
raise ExtractorError(f"Could not find stream URL in lovecdn.ru iframe")
# Usa iframe URL come referer
iframe_origin = f"https://{urlparse(iframe_url).netloc}"
stream_headers = {
'User-Agent': headers['User-Agent'],
'Referer': iframe_url,
'Origin': iframe_origin
}
# Determina endpoint in base al dominio dello stream
endpoint = "hls_key_proxy"
logger.info(f"Using lovecdn.ru stream with endpoint: {endpoint}")
return {
"destination_url": stream_url,
"request_headers": stream_headers,
"mediaflow_endpoint": endpoint,
}
resp = await self._make_request(iframe_url, headers=headers, timeout=12)
html = resp.text
except Exception as e:
raise ExtractorError(f"Failed to extract lovecdn.ru stream: {e}")
logger.warning(f"Error fetching iframe URL: {e}")
return None
# Pattern to extract EPlayerAuth.init block with authToken, channelKey, channelSalt
# Matches: EPlayerAuth.init({ authToken: '...', channelKey: '...', ..., channelSalt: '...' });
auth_pattern = r"EPlayerAuth\.init\s*\(\s*\{\s*authToken:\s*'([^']+)'"
channel_key_pattern = r"channelKey:\s*'([^']+)'"
channel_salt_pattern = r"channelSalt:\s*'([^']+)'"
# Pattern to extract server lookup base URL from fetchWithRetry call
lookup_pattern = r"fetchWithRetry\s*\(\s*'([^']+server_lookup\?channel_id=)"
auth_match = re.search(auth_pattern, html)
channel_key_match = re.search(channel_key_pattern, html)
channel_salt_match = re.search(channel_salt_pattern, html)
lookup_match = re.search(lookup_pattern, html)
if auth_match and channel_key_match and channel_salt_match:
result = {
"auth_token": auth_match.group(1),
"channel_key": channel_key_match.group(1),
"channel_salt": channel_salt_match.group(1),
}
if lookup_match:
result["server_lookup_url"] = lookup_match.group(1) + result["channel_key"]
return result
return None
async def _get_server_key(self, server_lookup_url: str, iframe_url: str) -> str | None:
"""
Fetch the server lookup URL and extract the server_key.
Args:
server_lookup_url: The server lookup URL
iframe_url: The iframe URL for extracting the host for headers
Returns:
The server_key or None if not found
"""
parsed = urlparse(iframe_url)
iframe_host = parsed.netloc
headers = {
"User-Agent": self._flaresolverr_user_agent or DEFAULT_DLHD_USER_AGENT,
"Referer": f"https://{iframe_host}/",
"Origin": f"https://{iframe_host}",
}
try:
resp = await self._make_request(server_lookup_url, headers=headers, timeout=10)
data = resp.json()
return data.get("server_key")
except Exception as e:
logger.warning(f"Error fetching server lookup: {e}")
return None
def _build_m3u8_url(self, server_key: str, channel_key: str) -> str:
"""
Build the m3u8 URL based on the server_key.
Args:
server_key: The server key from server lookup
channel_key: The channel key
Returns:
The m3u8 URL (with .css extension as per the original implementation)
"""
if server_key == "top1/cdn":
return f"https://top1.dvalna.ru/top1/cdn/{channel_key}/mono.css"
else:
return f"https://{server_key}new.dvalna.ru/{server_key}/{channel_key}/mono.css"
async def _extract_new_auth_flow(self, iframe_url: str, iframe_content: str, headers: dict) -> Dict[str, Any]:
"""Handles the new authentication flow found in recent updates."""
def _extract_params(js: str) -> Dict[str, Optional[str]]:
params = {}
patterns = {
@@ -143,82 +355,93 @@ class DLHDExtractor(BaseExtractor):
return params
params = _extract_params(iframe_content)
missing_params = [k for k, v in params.items() if not v]
if missing_params:
# This is not an error, just means it's not the new flow
raise ExtractorError(f"Not the new auth flow: missing params {missing_params}")
logger.info("New auth flow detected. Proceeding with POST auth.")
# 1. Initial Auth POST
auth_url = 'https://security.newkso.ru/auth2.php'
# Use files parameter to force multipart/form-data which is required by the server
# (None, value) tells httpx to send it as a form field, not a file upload
multipart_data = {
'channelKey': (None, params["channel_key"]),
'country': (None, params["auth_country"]),
'timestamp': (None, params["auth_ts"]),
'expiry': (None, params["auth_expiry"]),
'token': (None, params["auth_token"]),
}
auth_url = "https://security.newkso.ru/auth2.php"
iframe_origin = f"https://{urlparse(iframe_url).netloc}"
auth_headers = headers.copy()
auth_headers.update({
'Accept': '*/*',
'Accept-Language': 'en-US,en;q=0.9',
'Origin': iframe_origin,
'Referer': iframe_url,
'Sec-Fetch-Dest': 'empty',
'Sec-Fetch-Mode': 'cors',
'Sec-Fetch-Site': 'cross-site',
'Priority': 'u=1, i',
})
from mediaflow_proxy.utils.http_utils import create_httpx_client
auth_headers.update(
{
"Accept": "*/*",
"Accept-Language": "en-US,en;q=0.9",
"Origin": iframe_origin,
"Referer": iframe_url,
"Sec-Fetch-Dest": "empty",
"Sec-Fetch-Mode": "cors",
"Sec-Fetch-Site": "cross-site",
"Priority": "u=1, i",
}
)
# Build form data for multipart/form-data
form_data = aiohttp.FormData()
form_data.add_field("channelKey", params["channel_key"])
form_data.add_field("country", params["auth_country"])
form_data.add_field("timestamp", params["auth_ts"])
form_data.add_field("expiry", params["auth_expiry"])
form_data.add_field("token", params["auth_token"])
try:
async with create_httpx_client(verify=False) as client:
# Note: using 'files' instead of 'data' to ensure multipart/form-data Content-Type
auth_resp = await client.post(auth_url, files=multipart_data, headers=auth_headers, timeout=12)
auth_resp.raise_for_status()
auth_data = auth_resp.json()
if not (auth_data.get("valid") or auth_data.get("success")):
raise ExtractorError(f"Initial auth failed with response: {auth_data}")
async with create_aiohttp_session(auth_url, timeout=12, verify=False) as (session, proxy_url):
async with session.post(
auth_url,
headers=auth_headers,
data=form_data,
proxy=proxy_url,
) as response:
content = await response.read()
response.raise_for_status()
import json
auth_data = json.loads(content.decode("utf-8"))
if not (auth_data.get("valid") or auth_data.get("success")):
raise ExtractorError(f"Initial auth failed with response: {auth_data}")
logger.info("New auth flow: Initial auth successful.")
except ExtractorError:
raise
except Exception as e:
raise ExtractorError(f"New auth flow failed during initial auth POST: {e}")
# 2. Server Lookup
server_lookup_url = f"https://{urlparse(iframe_url).netloc}/server_lookup.js?channel_id={params['channel_key']}"
try:
# Use _make_request as it handles retries and expects JSON
# Use _make_request as it handles retries
lookup_resp = await self._make_request(server_lookup_url, headers=headers, timeout=10)
server_data = lookup_resp.json()
server_key = server_data.get('server_key')
server_key = server_data.get("server_key")
if not server_key:
raise ExtractorError(f"No server_key in lookup response: {server_data}")
logger.info(f"New auth flow: Server lookup successful - Server key: {server_key}")
except ExtractorError:
raise
except Exception as e:
raise ExtractorError(f"New auth flow failed during server lookup: {e}")
# 3. Build final stream URL
channel_key = params['channel_key']
auth_token = params['auth_token']
channel_key = params["channel_key"]
auth_token = params["auth_token"]
# The JS logic uses .css, not .m3u8
if server_key == 'top1/cdn':
stream_url = f'https://top1.newkso.ru/top1/cdn/{channel_key}/mono.css'
if server_key == "top1/cdn":
stream_url = f"https://top1.newkso.ru/top1/cdn/{channel_key}/mono.css"
else:
stream_url = f'https://{server_key}new.newkso.ru/{server_key}/{channel_key}/mono.css'
logger.info(f'New auth flow: Constructed stream URL: {stream_url}')
stream_url = f"https://{server_key}new.newkso.ru/{server_key}/{channel_key}/mono.css"
logger.info(f"New auth flow: Constructed stream URL: {stream_url}")
stream_headers = {
'User-Agent': headers['User-Agent'],
'Referer': iframe_url,
'Origin': iframe_origin,
'Authorization': f'Bearer {auth_token}',
'X-Channel-Key': channel_key
"User-Agent": headers["User-Agent"],
"Referer": iframe_url,
"Origin": iframe_origin,
"Authorization": f"Bearer {auth_token}",
"X-Channel-Key": channel_key,
}
return {
@@ -227,106 +450,255 @@ class DLHDExtractor(BaseExtractor):
"mediaflow_endpoint": "hls_manifest_proxy",
}
async def extract(self, url: str, **kwargs) -> Dict[str, Any]:
"""Main extraction flow: resolve base, fetch players, extract iframe, auth and final m3u8."""
baseurl = "https://dlhd.dad/"
async def _extract_lovecdn_stream(self, iframe_url: str, iframe_content: str, headers: dict) -> Dict[str, Any]:
"""
Alternative extractor for lovecdn.ru iframe that uses a different format.
"""
try:
# Look for direct stream URL patterns
m3u8_patterns = [
r'["\']([^"\']*\.m3u8[^"\']*)["\']',
r'source[:\s]+["\']([^"\']+)["\']',
r'file[:\s]+["\']([^"\']+\.m3u8[^"\']*)["\']',
r'hlsManifestUrl[:\s]*["\']([^"\']+)["\']',
]
def extract_channel_id(u: str) -> Optional[str]:
match_watch_id = re.search(r'watch\.php\?id=(\d+)', u)
if match_watch_id:
return match_watch_id.group(1)
return None
stream_url = None
for pattern in m3u8_patterns:
matches = re.findall(pattern, iframe_content)
for match in matches:
if ".m3u8" in match and match.startswith("http"):
stream_url = match
logger.info(f"Found direct m3u8 URL: {stream_url}")
break
if stream_url:
break
# Pattern 2: Look for dynamic URL construction
if not stream_url:
channel_match = re.search(r'(?:stream|channel)["\s:=]+["\']([^"\']+)["\']', iframe_content)
server_match = re.search(r'(?:server|domain|host)["\s:=]+["\']([^"\']+)["\']', iframe_content)
async def get_stream_data(initial_url: str):
daddy_origin = urlparse(baseurl).scheme + "://" + urlparse(baseurl).netloc
daddylive_headers = {
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
'Referer': baseurl,
'Origin': daddy_origin
if channel_match:
channel_name = channel_match.group(1)
server = server_match.group(1) if server_match else "newkso.ru"
stream_url = f"https://{server}/{channel_name}/mono.m3u8"
logger.info(f"Constructed stream URL: {stream_url}")
if not stream_url:
# Fallback: look for any URL that looks like a stream
url_pattern = r'https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*'
matches = re.findall(url_pattern, iframe_content)
if matches:
stream_url = matches[0]
logger.info(f"Found fallback stream URL: {stream_url}")
if not stream_url:
raise ExtractorError("Could not find stream URL in lovecdn.ru iframe")
# Use iframe URL as referer
iframe_origin = f"https://{urlparse(iframe_url).netloc}"
stream_headers = {"User-Agent": headers["User-Agent"], "Referer": iframe_url, "Origin": iframe_origin}
# Determine endpoint based on the stream domain
endpoint = "hls_key_proxy"
logger.info(f"Using lovecdn.ru stream with endpoint: {endpoint}")
return {
"destination_url": stream_url,
"request_headers": stream_headers,
"mediaflow_endpoint": endpoint,
}
except Exception as e:
raise ExtractorError(f"Failed to extract lovecdn.ru stream: {e}")
# 1. Request initial page
resp1 = await self._make_request(initial_url, headers=daddylive_headers, timeout=15)
player_links = re.findall(r'<button[^>]*data-url="([^"]+)"[^>]*>Player\s*\d+</button>', resp1.text)
if not player_links:
raise ExtractorError("No player links found on the page.")
async def _extract_direct_stream(self, channel_id: str) -> Dict[str, Any]:
"""
Direct stream extraction using server lookup API with the new auth flow.
This extracts auth_token, channel_key, channel_salt and computes key headers.
"""
# Common iframe domains for DLHD
iframe_domains = ["lefttoplay.xyz"]
for iframe_domain in iframe_domains:
try:
iframe_url = f"https://{iframe_domain}/premiumtv/daddyhd.php?id={channel_id}"
logger.info(f"Attempting extraction via {iframe_domain}")
# Prova tutti i player e raccogli tutti gli iframe validi
last_player_error = None
iframe_candidates = []
session_data = await self._extract_session_data(iframe_url, "dlhd.link")
for player_url in player_links:
try:
if not player_url.startswith('http'):
player_url = baseurl + player_url.lstrip('/')
daddylive_headers['Referer'] = player_url
daddylive_headers['Origin'] = player_url
resp2 = await self._make_request(player_url, headers=daddylive_headers, timeout=12)
iframes2 = re.findall(r'<iframe.*?src="([^"]*)"', resp2.text)
# Raccogli tutti gli iframe trovati
for iframe in iframes2:
if iframe not in iframe_candidates:
iframe_candidates.append(iframe)
logger.info(f"Found iframe candidate: {iframe}")
except Exception as e:
last_player_error = e
logger.warning(f"Failed to process player link {player_url}: {e}")
if not session_data:
logger.debug(f"No session data from {iframe_domain}")
continue
logger.info(f"Got session data from {iframe_domain}: channel_key={session_data['channel_key']}")
if not iframe_candidates:
if last_player_error:
raise ExtractorError(f"All player links failed. Last error: {last_player_error}")
raise ExtractorError("No valid iframe found in any player page")
# Prova ogni iframe finché uno non funziona
last_iframe_error = None
for iframe_candidate in iframe_candidates:
try:
logger.info(f"Trying iframe: {iframe_candidate}")
iframe_domain = urlparse(iframe_candidate).netloc
if not iframe_domain:
logger.warning(f"Invalid iframe URL format: {iframe_candidate}")
continue
self._iframe_context = iframe_candidate
resp3 = await self._make_request(iframe_candidate, headers=daddylive_headers, timeout=12)
iframe_content = resp3.text
logger.info(f"Successfully loaded iframe from: {iframe_domain}")
if 'lovecdn.ru' in iframe_domain:
logger.info("Detected lovecdn.ru iframe - using alternative extraction")
return await self._extract_lovecdn_stream(iframe_candidate, iframe_content, daddylive_headers)
else:
logger.info("Attempting new auth flow extraction.")
return await self._extract_new_auth_flow(iframe_candidate, iframe_content, daddylive_headers)
except Exception as e:
logger.warning(f"Failed to process iframe {iframe_candidate}: {e}")
last_iframe_error = e
# Get server key
if "server_lookup_url" not in session_data:
logger.debug(f"No server lookup URL from {iframe_domain}")
continue
raise ExtractorError(f"All iframe candidates failed. Last error: {last_iframe_error}")
server_key = await self._get_server_key(session_data["server_lookup_url"], iframe_url)
if not server_key:
logger.debug(f"No server key from {iframe_domain}")
continue
logger.info(f"Got server key: {server_key}")
# Build m3u8 URL
m3u8_url = self._build_m3u8_url(server_key, session_data["channel_key"])
logger.info(f"M3U8 URL: {m3u8_url}")
# Build stream headers with auth
iframe_origin = f"https://{iframe_domain}"
stream_headers = {
"User-Agent": self._flaresolverr_user_agent or DEFAULT_DLHD_USER_AGENT,
"Referer": iframe_url,
"Origin": iframe_origin,
"Authorization": f"Bearer {session_data['auth_token']}",
}
# Return the result with key header parameters
# These will be used to compute headers when fetching keys
return {
"destination_url": m3u8_url,
"request_headers": stream_headers,
"mediaflow_endpoint": "hls_key_proxy",
# Force playlist processing since DLHD uses .css extension for m3u8
"force_playlist_proxy": True,
# Key header computation parameters
"dlhd_key_params": {
"channel_salt": session_data["channel_salt"],
"auth_token": session_data["auth_token"],
"iframe_url": iframe_url,
},
}
except Exception as e:
logger.warning(f"Failed extraction via {iframe_domain}: {e}")
continue
raise ExtractorError(f"Failed to extract stream from all iframe domains for channel {channel_id}")
async def extract(self, url: str, **kwargs) -> Dict[str, Any]:
"""Main extraction flow - uses direct server lookup with new auth flow."""
def extract_channel_id(u: str) -> Optional[str]:
match_watch_id = re.search(r"watch\.php\?id=(\d+)", u)
if match_watch_id:
return match_watch_id.group(1)
# Also try stream-XXX pattern
match_stream = re.search(r"stream-(\d+)", u)
if match_stream:
return match_stream.group(1)
return None
try:
channel_id = extract_channel_id(url)
if not channel_id:
raise ExtractorError(f"Unable to extract channel ID from {url}")
logger.info(f"Using base domain: {baseurl}")
return await get_stream_data(url)
logger.info(f"Extracting DLHD stream for channel ID: {channel_id}")
# Try direct stream extraction with new auth flow
try:
return await self._extract_direct_stream(channel_id)
except ExtractorError as e:
logger.warning(f"Direct stream extraction failed: {e}")
# Fallback to legacy iframe-based extraction if direct fails
logger.info("Falling back to iframe-based extraction...")
return await self._extract_via_iframe(url, channel_id)
except Exception as e:
raise ExtractorError(f"Extraction failed: {str(e)}")
async def _extract_via_iframe(self, url: str, channel_id: str) -> Dict[str, Any]:
"""Legacy iframe-based extraction flow - used as fallback."""
baseurl = "https://dlhd.dad/"
daddy_origin = urlparse(baseurl).scheme + "://" + urlparse(baseurl).netloc
daddylive_headers = {
"User-Agent": self._flaresolverr_user_agent
or "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
"Referer": baseurl,
"Origin": daddy_origin,
}
# 1. Request initial page - use FlareSolverr if available to bypass Cloudflare
use_flaresolverr = settings.flaresolverr_url is not None
resp1 = await self._make_request(url, headers=daddylive_headers, timeout=15, use_flaresolverr=use_flaresolverr)
resp1_text = resp1.text
# Update headers with FlareSolverr user-agent after initial request
if self._flaresolverr_user_agent:
daddylive_headers["User-Agent"] = self._flaresolverr_user_agent
player_links = re.findall(r'<button[^>]*data-url="([^"]+)"[^>]*>Player\s*\d+</button>', resp1_text)
if not player_links:
raise ExtractorError("No player links found on the page.")
# Try all players and collect all valid iframes
last_player_error = None
iframe_candidates = []
for player_url in player_links:
try:
if not player_url.startswith("http"):
player_url = baseurl + player_url.lstrip("/")
daddylive_headers["Referer"] = player_url
daddylive_headers["Origin"] = player_url
resp2 = await self._make_request(player_url, headers=daddylive_headers, timeout=12)
resp2_text = resp2.text
iframes2 = re.findall(r'<iframe.*?src="([^"]*)"', resp2_text)
# Collect all found iframes
for iframe in iframes2:
if iframe not in iframe_candidates:
iframe_candidates.append(iframe)
logger.info(f"Found iframe candidate: {iframe}")
except Exception as e:
last_player_error = e
logger.warning(f"Failed to process player link {player_url}: {e}")
continue
if not iframe_candidates:
if last_player_error:
raise ExtractorError(f"All player links failed. Last error: {last_player_error}")
raise ExtractorError("No valid iframe found in any player page")
# Try each iframe until one works
last_iframe_error = None
for iframe_candidate in iframe_candidates:
try:
logger.info(f"Trying iframe: {iframe_candidate}")
iframe_domain = urlparse(iframe_candidate).netloc
if not iframe_domain:
logger.warning(f"Invalid iframe URL format: {iframe_candidate}")
continue
self._iframe_context = iframe_candidate
resp3 = await self._make_request(iframe_candidate, headers=daddylive_headers, timeout=12)
iframe_content = resp3.text
logger.info(f"Successfully loaded iframe from: {iframe_domain}")
if "lovecdn.ru" in iframe_domain:
logger.info("Detected lovecdn.ru iframe - using alternative extraction")
return await self._extract_lovecdn_stream(iframe_candidate, iframe_content, daddylive_headers)
else:
logger.info("Attempting new auth flow extraction.")
return await self._extract_new_auth_flow(iframe_candidate, iframe_content, daddylive_headers)
except Exception as e:
logger.warning(f"Failed to process iframe {iframe_candidate}: {e}")
last_iframe_error = e
continue
raise ExtractorError(f"All iframe candidates failed. Last error: {last_iframe_error}")