mirror of
https://github.com/unshackle-dl/unshackle.git
synced 2026-11-16 22:15:07 +00:00
serve.users.<key>.cdm and service_config give each API key its own device and service config. Service.IDENTITY_CACHE keys route to a per-key directory that clients never receive
190 lines
9.3 KiB
Python
190 lines
9.3 KiB
Python
"""An API key's own cdm and service_config entries, and the identity cache a server device keeps per key."""
|
|
|
|
import asyncio
|
|
import base64
|
|
import json
|
|
import zlib
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from unshackle.core.api import handlers
|
|
from unshackle.core.api.errors import APIError
|
|
from unshackle.core.api.input_bridge import AuthStatus
|
|
from unshackle.core.api.session_store import get_session_store
|
|
from unshackle.core.config import config
|
|
|
|
|
|
@pytest.fixture
|
|
def server(monkeypatch, tmp_path):
|
|
monkeypatch.setattr(config, "cdm", {"EXAMPLE": {"widevine": "shared_wv", "playready": "shared_pr"}, "OTHER": "x"})
|
|
monkeypatch.setattr(config.directories, "cache", tmp_path)
|
|
monkeypatch.setattr(handlers.Services, "get_tag", staticmethod(lambda tag: tag.upper()))
|
|
return tmp_path
|
|
|
|
|
|
def test_a_key_entry_replaces_the_whole_server_entry(server):
|
|
user = {"cdm": {"example": "own_pr"}}
|
|
assert handlers.key_cdm_config(user).cdm == {"OTHER": "x", "example": "own_pr"}
|
|
assert handlers.configured_cdm_name("EXAMPLE", "widevine", handlers.key_cdm_config(user)) == "own_pr"
|
|
assert handlers.key_cdm_config({}) is config
|
|
|
|
|
|
def test_licence_device_comes_from_the_key_entry(server):
|
|
assert handlers.resolve_device_name({"cdm": {"EXAMPLE": "own"}}, "playready", "EXAMPLE") == "own"
|
|
assert handlers.resolve_device_name({}, "playready", "EXAMPLE") == "shared_pr"
|
|
|
|
|
|
def test_a_session_keeps_the_user_config_it_was_created_with(server, monkeypatch):
|
|
session = SimpleNamespace(user_config={"cdm": {"EXAMPLE": "pinned"}})
|
|
monkeypatch.setattr(handlers, "serve_user_config", lambda key: {"cdm": {"EXAMPLE": "reloaded"}})
|
|
assert handlers.session_user_config(session, None)["cdm"]["EXAMPLE"] == "pinned"
|
|
assert handlers.session_user_config(SimpleNamespace(), None)["cdm"]["EXAMPLE"] == "reloaded"
|
|
|
|
|
|
def test_the_key_block_beats_the_server_config_and_profile_sections(server, monkeypatch):
|
|
base = {"device_id": "server", "device_key": "server", "p1": {"device_id": "p1", "other": 1}, "urls": {"a": "b"}}
|
|
monkeypatch.setattr(handlers, "load_service_yaml", lambda service: json.loads(json.dumps(base)))
|
|
user = {"service_config": {"example": {"device_id": "key", "device_key": "key"}}}
|
|
|
|
merged = handlers.key_service_yaml("EXAMPLE", user)
|
|
|
|
assert merged["device_id"] == merged["device_key"] == "key"
|
|
assert merged["p1"] == {"device_id": "key", "other": 1}
|
|
assert merged["urls"] == {"a": "b"}
|
|
assert handlers.key_service_yaml("EXAMPLE", {})["device_id"] == "server"
|
|
assert handlers.key_owns_identity(user, "EXAMPLE") and not handlers.key_owns_identity(user, "OTHER")
|
|
|
|
|
|
class _Service:
|
|
IDENTITY_CACHE = ("keys/",)
|
|
|
|
|
|
def test_identity_keys_live_in_the_api_key_directory_and_never_reach_the_client(server):
|
|
cache = handlers.keyed_cache("_s", _Service(), "EXAMPLE", "k", {}, temporary=True)
|
|
cache.get("keys/device1").set("keys")
|
|
cache.get("tokens").set("login")
|
|
|
|
assert set(handlers.collect_cache_files("_s")) == {"tokens"}
|
|
assert list((server / "_identity").rglob("device1.json"))
|
|
assert handlers.keyed_cache("_t", _Service(), "EXAMPLE", "k", {}, True).get("keys/device1").data == "keys"
|
|
|
|
text = base64.b64encode(zlib.compress(b'{"data": "planted"}')).decode("ascii")
|
|
handlers.write_client_cache({"keys/device1": text}, "_s")
|
|
assert cache.get("keys/device1").data == "keys"
|
|
|
|
|
|
def test_a_lasting_cache_keeps_identity_keys_apart_only_for_a_key_with_its_own_identity(server):
|
|
own = {"service_config": {"EXAMPLE": {"device_id": "key"}}}
|
|
assert handlers.keyed_cache("_accounts/EXAMPLE/p", _Service(), "EXAMPLE", "k", {}).route is None
|
|
assert handlers.keyed_cache("_accounts/EXAMPLE/p", _Service(), "EXAMPLE", "k", own).route is not None
|
|
assert handlers.keyed_cache("_s", object(), "EXAMPLE", "k", own, temporary=True).route is None
|
|
|
|
|
|
def test_a_job_is_refused_for_a_key_with_its_own_identity(server, monkeypatch):
|
|
monkeypatch.setattr(handlers, "server_cdm_allowed", lambda request, service: True)
|
|
monkeypatch.setattr(handlers, "server_cdm_max_height", lambda request, service: None)
|
|
monkeypatch.setattr(handlers, "serve_user_config", lambda key: {"cdm": {"EXAMPLE": "own"}})
|
|
with pytest.raises(APIError, match="its own"):
|
|
handlers.enforce_download_gates({"service": "EXAMPLE"})
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"user_cfg, problem",
|
|
[
|
|
({"services": {"EXAMPLE": {}}}, "list of service tags"),
|
|
({"cdm": "dev"}, "mapping of service tag"),
|
|
({"cdm": {"default": "dev"}}, "a key has no default entry"),
|
|
({"service_config": {"DEFAULT": {"device_id": "x"}}}, "a key has no default entry"),
|
|
({"cdm": {"EXAMPLE": {"widevine": "dev", "tiers": "x"}}}, "device name or a widevine/playready/default"),
|
|
({"cdm": {"EXAMPLE": "missing"}}, "no CDM device named 'missing'"),
|
|
({"service_config": {"EXAMPLE": "device_id"}}, "mapping of config key"),
|
|
],
|
|
)
|
|
def test_bad_key_config_is_refused_at_load(server, monkeypatch, user_cfg, problem):
|
|
monkeypatch.setattr(handlers.Services, "get_tags", staticmethod(lambda: ["EXAMPLE"]))
|
|
assert problem in handlers.key_config_error("serve.users.u", user_cfg)
|
|
|
|
|
|
def test_a_known_device_passes_validation(server, monkeypatch):
|
|
monkeypatch.setattr(handlers.Services, "get_tags", staticmethod(lambda: ["EXAMPLE"]))
|
|
monkeypatch.setattr(handlers, "detect_cdm_type", lambda name, cfg: "playready")
|
|
assert handlers.key_config_error("u", {"cdm": {"EXAMPLE": {"playready": "dev"}}, "service_config": {}}) is None
|
|
assert handlers.key_config_error("u", {"cdm": {"EXAMPLE": {"default": "dev"}}, "service_config": None}) is None
|
|
assert handlers.key_config_error("u", {"cdm": {"EXAMPLE": {"widevine": "dev"}}}) is not None
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"server_cdm, sent, own, returned",
|
|
[
|
|
(True, {}, True, {"tokens", "keys/planted"}),
|
|
(False, {}, True, {"tokens", "keys/planted"}),
|
|
(False, {"cdm_type": "playready", "cdm_relay": True}, True, {"tokens", "keys/planted"}),
|
|
(False, {"cdm_type": "playready", "cdm_relay": True}, False, {"tokens", "keys/device1", "keys/planted"}),
|
|
],
|
|
)
|
|
def test_a_session_keeps_identity_keys_from_the_client_unless_the_identity_is_the_clients(
|
|
server, monkeypatch, server_cdm, sent, own, returned
|
|
):
|
|
class Service(_Service):
|
|
_input_bridge = log = cache = None
|
|
|
|
def authenticate(self, cookies, credential):
|
|
self.cache.get("keys/device1").set("identity")
|
|
self.cache.get("tokens").set("login")
|
|
|
|
user = {"service_config": {"EXAMPLE": {"device_id": "key"}}} if own else {}
|
|
text = base64.b64encode(zlib.compress(b'{"data": "x"}')).decode("ascii")
|
|
monkeypatch.setattr(handlers, "validate_service", lambda service, request=None: service)
|
|
monkeypatch.setattr(handlers, "resolve_handler_proxy", lambda *args: (None, []))
|
|
monkeypatch.setattr(handlers, "server_account_for", lambda *args: False)
|
|
monkeypatch.setattr(handlers, "serve_user_config", lambda key: user)
|
|
monkeypatch.setattr(handlers, "choose_session_cdm", lambda *args: (server_cdm, None))
|
|
monkeypatch.setattr(handlers.Services, "load", lambda service: Service)
|
|
monkeypatch.setattr(handlers, "create_service_instance", lambda *args, **kwargs: (Service(), None, None))
|
|
|
|
async def run():
|
|
data = {"service": "EXAMPLE", "title_id": "t", "cookies": "x", "cache": {"keys/planted": text}, **sent}
|
|
response = await handlers.session_create_handler(data)
|
|
session = get_session_store().peek(json.loads(response.body)["session_id"])
|
|
try:
|
|
for _ in range(250):
|
|
if session.auth_status != AuthStatus.AUTHENTICATING:
|
|
break
|
|
await asyncio.sleep(0.02)
|
|
return session, set(handlers.collect_cache_files(session.cache_tag))
|
|
finally:
|
|
await get_session_store().delete(session.session_id)
|
|
|
|
session, sent_back = asyncio.run(run())
|
|
|
|
assert session.user_config is user
|
|
assert sent_back == returned
|
|
|
|
|
|
def test_a_reload_checks_key_devices_against_the_new_config(server, monkeypatch):
|
|
monkeypatch.setattr(handlers.Services, "get_tags", staticmethod(lambda: ["EXAMPLE"]))
|
|
fresh = SimpleNamespace(remote_cdm=[{"name": "new_remote", "device_type": "PLAYREADY"}])
|
|
user = {"cdm": {"EXAMPLE": "new_remote"}}
|
|
assert handlers.key_config_error("u", user, fresh) is None
|
|
assert handlers.key_config_error("u", user) is not None
|
|
|
|
|
|
def test_a_block_value_reaches_only_plain_values_of_other_sections(server, monkeypatch):
|
|
base = {"p1": {"device_id": "p1", "headers": {"a": "b"}}, "device_key": "server"}
|
|
monkeypatch.setattr(handlers, "load_service_yaml", lambda service: json.loads(json.dumps(base)))
|
|
block = {"device_id": "key", "headers": {"c": "d"}, "device_key": {"nested": 1}}
|
|
|
|
merged = handlers.key_service_yaml("EXAMPLE", {"service_config": {"EXAMPLE": block}})
|
|
|
|
assert merged["p1"] == {"device_id": "key", "headers": {"a": "b"}}
|
|
assert merged["device_key"] == {"nested": 1}
|
|
|
|
|
|
def test_a_removed_key_loses_its_identity_cache(server):
|
|
handlers.keyed_cache("_s", _Service(), "EXAMPLE", "gone", {}, True).get("keys/device1").set("keys")
|
|
handlers.keyed_cache("_s", _Service(), "EXAMPLE", "kept", {}, True).get("keys/device1").set("keys")
|
|
handlers.drop_identity_cache({"gone"})
|
|
assert not (server / "_identity" / handlers.key_namespace("gone")).exists()
|
|
assert (server / "_identity" / handlers.key_namespace("kept")).exists()
|